49357c4709666bc237d279028800ed529304fe5a
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 /* FIXME: kettenis/2000-05-21: Right now more than a few i386 targets
28 define their own routines to manage the floating-point registers in
29 GDB's register array. Most (if not all) of these targets use the
30 format used by the "fsave" instruction in their communication with
31 the OS. They should all be converted to use the routines below. */
33 /* At fsave_offset[REGNUM] you'll find the offset to the location in
34 the data structure used by the "fsave" instruction where GDB
35 register REGNUM is stored. */
37 static int fsave_offset
[] =
39 28 + 0 * FPU_REG_RAW_SIZE
, /* FP0_REGNUM through ... */
40 28 + 1 * FPU_REG_RAW_SIZE
,
41 28 + 2 * FPU_REG_RAW_SIZE
,
42 28 + 3 * FPU_REG_RAW_SIZE
,
43 28 + 4 * FPU_REG_RAW_SIZE
,
44 28 + 5 * FPU_REG_RAW_SIZE
,
45 28 + 6 * FPU_REG_RAW_SIZE
,
46 28 + 7 * FPU_REG_RAW_SIZE
, /* ... FP7_REGNUM. */
47 0, /* FCTRL_REGNUM (16 bits). */
48 4, /* FSTAT_REGNUM (16 bits). */
49 8, /* FTAG_REGNUM (16 bits). */
50 16, /* FCS_REGNUM (16 bits). */
51 12, /* FCOFF_REGNUM. */
53 20, /* FDOFF_REGNUM. */
54 18 /* FOP_REGNUM (bottom 11 bits). */
57 #define FSAVE_ADDR(fsave, regnum) (fsave + fsave_offset[regnum - FP0_REGNUM])
60 /* Fill register REGNUM in GDB's register array with the appropriate
61 value from *FSAVE. This function masks off any of the reserved
65 i387_supply_register (int regnum
, char *fsave
)
67 /* Most of the FPU control registers occupy only 16 bits in
68 the fsave area. Give those a special treatment. */
69 if (regnum
>= FIRST_FPU_CTRL_REGNUM
70 && regnum
!= FCOFF_REGNUM
&& regnum
!= FDOFF_REGNUM
)
72 unsigned int val
= *(unsigned short *) (FSAVE_ADDR (fsave
, regnum
));
74 if (regnum
== FOP_REGNUM
)
76 val
&= ((1 << 11) - 1);
77 supply_register (regnum
, (char *) &val
);
80 supply_register (regnum
, (char *) &val
);
83 supply_register (regnum
, FSAVE_ADDR (fsave
, regnum
));
86 /* Fill GDB's register array with the floating-point register values
87 in *FSAVE. This function masks off any of the reserved
91 i387_supply_fsave (char *fsave
)
95 for (i
= FP0_REGNUM
; i
<= LAST_FPU_CTRL_REGNUM
; i
++)
96 i387_supply_register (i
, fsave
);
99 /* Fill register REGNUM (if it is a floating-point register) in *FSAVE
100 with the value in GDB's register array. If REGNUM is -1, do this
101 for all registers. This function doesn't touch any of the reserved
105 i387_fill_fsave (char *fsave
, int regnum
)
109 for (i
= FP0_REGNUM
; i
<= LAST_FPU_CTRL_REGNUM
; i
++)
110 if (regnum
== -1 || regnum
== i
)
112 /* Most of the FPU control registers occupy only 16 bits in
113 the fsave area. Give those a special treatment. */
114 if (i
>= FIRST_FPU_CTRL_REGNUM
115 && i
!= FCOFF_REGNUM
&& i
!= FDOFF_REGNUM
)
119 unsigned short oldval
, newval
;
121 /* The opcode occupies only 11 bits. */
122 oldval
= (*(unsigned short *) (FSAVE_ADDR (fsave
, i
)));
123 newval
= *(unsigned short *) ®isters
[REGISTER_BYTE (i
)];
124 newval
&= ((1 << 11) - 1);
125 newval
|= oldval
& ~((1 << 11) - 1);
126 memcpy (FSAVE_ADDR (fsave
, i
), &newval
, 2);
129 memcpy (FSAVE_ADDR (fsave
, i
), ®isters
[REGISTER_BYTE (i
)], 2);
132 memcpy (FSAVE_ADDR (fsave
, i
), ®isters
[REGISTER_BYTE (i
)],
133 REGISTER_RAW_SIZE (i
));
138 /* At fxsave_offset[REGNUM] you'll find the offset to the location in
139 the data structure used by the "fxsave" instruction where GDB
140 register REGNUM is stored. */
142 static int fxsave_offset
[] =
144 32, /* FP0_REGNUM through ... */
151 144, /* ... FP7_REGNUM (80 bits each). */
152 0, /* FCTRL_REGNUM (16 bits). */
153 2, /* FSTAT_REGNUM (16 bits). */
154 4, /* FTAG_REGNUM (16 bits). */
155 12, /* FCS_REGNUM (16 bits). */
156 8, /* FCOFF_REGNUM. */
157 20, /* FDS_REGNUM (16 bits). */
158 16, /* FDOFF_REGNUM. */
159 6, /* FOP_REGNUM (bottom 11 bits). */
160 160, /* XMM0_REGNUM through ... */
167 272, /* ... XMM7_REGNUM (128 bits each). */
168 24, /* MXCSR_REGNUM. */
171 #define FXSAVE_ADDR(fxsave, regnum) \
172 (fxsave + fxsave_offset[regnum - FP0_REGNUM])
174 static int i387_tag (unsigned char *raw
);
177 /* Fill GDB's register array with the floating-point and SSE register
178 values in *FXSAVE. This function masks off any of the reserved
182 i387_supply_fxsave (char *fxsave
)
186 for (i
= FP0_REGNUM
; i
<= MXCSR_REGNUM
; i
++)
188 /* Most of the FPU control registers occupy only 16 bits in
189 the fxsave area. Give those a special treatment. */
190 if (i
>= FIRST_FPU_CTRL_REGNUM
&& i
< XMM0_REGNUM
191 && i
!= FCOFF_REGNUM
&& i
!= FDOFF_REGNUM
)
193 unsigned long val
= *(unsigned short *) (FXSAVE_ADDR (fxsave
, i
));
197 val
&= ((1 << 11) - 1);
198 supply_register (i
, (char *) &val
);
200 else if (i
== FTAG_REGNUM
)
202 /* The fxsave area contains a simplified version of the
203 tag word. We have to look at the actual 80-bit FP
204 data to recreate the traditional i387 tag word. */
206 unsigned long ftag
= 0;
211 fstat
= *(unsigned short *) (FXSAVE_ADDR (fxsave
, FSTAT_REGNUM
));
212 top
= ((fstat
>> 11) & 0x111);
214 for (fpreg
= 7; fpreg
>= 0; fpreg
--)
218 if (val
& (1 << fpreg
))
220 int regnum
= (fpreg
+ 8 - top
) % 8 + FP0_REGNUM
;
221 tag
= i387_tag (FXSAVE_ADDR (fxsave
, regnum
));
224 ftag
|= tag
<< (2 * fpreg
);
226 supply_register (i
, (char *) &ftag
);
229 supply_register (i
, (char *) &val
);
232 supply_register (i
, FXSAVE_ADDR (fxsave
, i
));
236 /* Fill register REGNUM (if it is a floating-point or SSE register) in
237 *FXSAVE with the value in GDB's register array. If REGNUM is -1, do
238 this for all registers. This function doesn't touch any of the
239 reserved bits in *FXSAVE. */
242 i387_fill_fxsave (char *fxsave
, int regnum
)
246 for (i
= FP0_REGNUM
; i
<= MXCSR_REGNUM
; i
++)
247 if (regnum
== -1 || regnum
== i
)
249 /* Most of the FPU control registers occupy only 16 bits in
250 the fxsave area. Give those a special treatment. */
251 if (i
>= FIRST_FPU_CTRL_REGNUM
&& i
< XMM0_REGNUM
252 && i
!= FCOFF_REGNUM
&& i
!= FDOFF_REGNUM
)
256 unsigned short oldval
, newval
;
258 /* The opcode occupies only 11 bits. */
259 oldval
= (*(unsigned short *) (FXSAVE_ADDR (fxsave
, i
)));
260 newval
= *(unsigned short *) ®isters
[REGISTER_BYTE (i
)];
261 newval
&= ((1 << 11) - 1);
262 newval
|= oldval
& ~((1 << 11) - 1);
263 memcpy (FXSAVE_ADDR (fxsave
, i
), &newval
, 2);
265 else if (i
== FTAG_REGNUM
)
267 /* Converting back is much easier. */
269 unsigned char val
= 0;
273 ftag
= *(unsigned short *) ®isters
[REGISTER_BYTE (i
)];
275 for (fpreg
= 7; fpreg
>= 0; fpreg
--)
277 int tag
= (ftag
>> (fpreg
* 2)) & 0x11;
283 memcpy (FXSAVE_ADDR (fxsave
, i
), &val
, 2);
286 memcpy (FXSAVE_ADDR (fxsave
, i
),
287 ®isters
[REGISTER_BYTE (i
)], 2);
290 memcpy (FXSAVE_ADDR (fxsave
, i
), ®isters
[REGISTER_BYTE (i
)],
291 REGISTER_RAW_SIZE (i
));
295 /* Recreate the FTW (tag word) valid bits from the 80-bit FP data in
299 i387_tag (unsigned char *raw
)
302 unsigned int exponent
;
303 unsigned long fraction
[2];
305 integer
= raw
[7] & 0x80;
306 exponent
= (((raw
[9] & 0x7f) << 8) | raw
[8]);
307 fraction
[0] = ((raw
[3] << 24) | (raw
[2] << 16) | (raw
[1] << 8) | raw
[0]);
308 fraction
[1] = (((raw
[7] & 0x7f) << 24) | (raw
[6] << 16)
309 | (raw
[5] << 8) | raw
[4]);
311 if (exponent
== 0x7fff)
316 else if (exponent
== 0x0000)
331 if (fraction
[0] == 0x0000 && fraction
[1] == 0x0000 && !integer
)
This page took 0.03597 seconds and 3 git commands to generate.