]>
Commit | Line | Data |
---|---|---|
58caa3dc | 1 | /* i387-specific utility functions, for the remote server for GDB. |
213516ef | 2 | Copyright (C) 2000-2023 Free Software Foundation, Inc. |
58caa3dc DJ |
3 | |
4 | This file is part of GDB. | |
5 | ||
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 | |
a9762ec7 | 8 | the Free Software Foundation; either version 3 of the License, or |
58caa3dc DJ |
9 | (at your option) any later version. |
10 | ||
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. | |
15 | ||
16 | You should have received a copy of the GNU General Public License | |
a9762ec7 | 17 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
58caa3dc DJ |
18 | |
19 | #include "server.h" | |
0d62e5e8 | 20 | #include "i387-fp.h" |
268a13a5 | 21 | #include "gdbsupport/x86-xstate.h" |
03e6fe7e JB |
22 | #include "nat/x86-xstate.h" |
23 | ||
24 | /* Default to SSE. */ | |
25 | static unsigned long long x86_xcr0 = X86_XSTATE_SSE_MASK; | |
58caa3dc | 26 | |
a196ebeb WT |
27 | static const int num_mpx_bnd_registers = 4; |
28 | static const int num_mpx_cfg_registers = 2; | |
01f9f808 | 29 | static const int num_avx512_k_registers = 8; |
51547df6 | 30 | static const int num_pkeys_registers = 1; |
a196ebeb | 31 | |
03e6fe7e JB |
32 | static x86_xsave_layout xsave_layout; |
33 | ||
58caa3dc DJ |
34 | /* Note: These functions preserve the reserved bits in control registers. |
35 | However, gdbserver promptly throws away that information. */ | |
36 | ||
37 | /* These structs should have the proper sizes and alignment on both | |
38 | i386 and x86-64 machines. */ | |
39 | ||
b3e17448 JB |
40 | struct i387_fsave |
41 | { | |
58caa3dc DJ |
42 | /* All these are only sixteen bits, plus padding, except for fop (which |
43 | is only eleven bits), and fooff / fioff (which are 32 bits each). */ | |
0c2ead7e DJ |
44 | unsigned short fctrl; |
45 | unsigned short pad1; | |
46 | unsigned short fstat; | |
47 | unsigned short pad2; | |
48 | unsigned short ftag; | |
49 | unsigned short pad3; | |
58caa3dc DJ |
50 | unsigned int fioff; |
51 | unsigned short fiseg; | |
52 | unsigned short fop; | |
53 | unsigned int fooff; | |
0c2ead7e DJ |
54 | unsigned short foseg; |
55 | unsigned short pad4; | |
58caa3dc DJ |
56 | |
57 | /* Space for eight 80-bit FP values. */ | |
f450004a | 58 | unsigned char st_space[80]; |
58caa3dc DJ |
59 | }; |
60 | ||
b3e17448 JB |
61 | struct i387_fxsave |
62 | { | |
58caa3dc DJ |
63 | /* All these are only sixteen bits, plus padding, except for fop (which |
64 | is only eleven bits), and fooff / fioff (which are 32 bits each). */ | |
65 | unsigned short fctrl; | |
66 | unsigned short fstat; | |
67 | unsigned short ftag; | |
68 | unsigned short fop; | |
69 | unsigned int fioff; | |
0c2ead7e DJ |
70 | unsigned short fiseg; |
71 | unsigned short pad1; | |
58caa3dc | 72 | unsigned int fooff; |
0c2ead7e DJ |
73 | unsigned short foseg; |
74 | unsigned short pad12; | |
58caa3dc DJ |
75 | |
76 | unsigned int mxcsr; | |
0c2ead7e | 77 | unsigned int pad3; |
58caa3dc DJ |
78 | |
79 | /* Space for eight 80-bit FP values in 128-bit spaces. */ | |
f450004a | 80 | unsigned char st_space[128]; |
58caa3dc DJ |
81 | |
82 | /* Space for eight 128-bit XMM values, or 16 on x86-64. */ | |
f450004a | 83 | unsigned char xmm_space[256]; |
58caa3dc DJ |
84 | }; |
85 | ||
1f14ecbe AP |
86 | gdb_static_assert (sizeof(i387_fxsave) == 416); |
87 | ||
b3e17448 JB |
88 | struct i387_xsave : public i387_fxsave |
89 | { | |
1570b33e L |
90 | unsigned char reserved1[48]; |
91 | ||
92 | /* The extended control register 0 (the XFEATURE_ENABLED_MASK | |
93 | register). */ | |
94 | unsigned long long xcr0; | |
95 | ||
96 | unsigned char reserved2[40]; | |
97 | ||
98 | /* The XSTATE_BV bit vector. */ | |
99 | unsigned long long xstate_bv; | |
100 | ||
1f14ecbe AP |
101 | /* The XCOMP_BV bit vector. */ |
102 | unsigned long long xcomp_bv; | |
a196ebeb | 103 | |
1f14ecbe | 104 | unsigned char reserved3[48]; |
a196ebeb | 105 | |
1f14ecbe AP |
106 | /* Byte 576. End of registers with fixed position in XSAVE. |
107 | The position of other XSAVE registers will be calculated | |
108 | from the appropriate CPUID calls. */ | |
01f9f808 | 109 | |
1f14ecbe AP |
110 | private: |
111 | /* Base address of XSAVE data as an unsigned char *. Used to derive | |
112 | pointers to XSAVE state components in the extended state | |
113 | area. */ | |
114 | unsigned char *xsave () | |
115 | { return reinterpret_cast<unsigned char *> (this); } | |
01f9f808 | 116 | |
1f14ecbe AP |
117 | public: |
118 | /* Memory address of eight upper 128-bit YMM values, or 16 on x86-64. */ | |
119 | unsigned char *ymmh_space () | |
120 | { return xsave () + xsave_layout.avx_offset; } | |
01f9f808 | 121 | |
1f14ecbe AP |
122 | /* Memory address of 4 bound registers values of 128 bits. */ |
123 | unsigned char *bndregs_space () | |
124 | { return xsave () + xsave_layout.bndregs_offset; } | |
01f9f808 | 125 | |
1f14ecbe AP |
126 | /* Memory address of 2 MPX configuration registers of 64 bits |
127 | plus reserved space. */ | |
128 | unsigned char *bndcfg_space () | |
129 | { return xsave () + xsave_layout.bndcfg_offset; } | |
130 | ||
131 | /* Memory address of 8 OpMask register values of 64 bits. */ | |
132 | unsigned char *k_space () | |
133 | { return xsave () + xsave_layout.k_offset; } | |
134 | ||
135 | /* Memory address of 16 256-bit zmm0-15. */ | |
136 | unsigned char *zmmh_space () | |
137 | { return xsave () + xsave_layout.zmm_h_offset; } | |
138 | ||
139 | /* Memory address of 16 512-bit zmm16-31 values. */ | |
140 | unsigned char *zmm16_space () | |
141 | { return xsave () + xsave_layout.zmm_offset; } | |
142 | ||
143 | /* Memory address of 1 32-bit PKRU register. The HW XSTATE size for this | |
144 | feature is actually 64 bits, but WRPKRU/RDPKRU instructions ignore upper | |
145 | 32 bits. */ | |
146 | unsigned char *pkru_space () | |
147 | { return xsave () + xsave_layout.pkru_offset; } | |
1570b33e L |
148 | }; |
149 | ||
1f14ecbe AP |
150 | gdb_static_assert (sizeof(i387_xsave) == 576); |
151 | ||
58caa3dc | 152 | void |
442ea881 | 153 | i387_cache_to_fsave (struct regcache *regcache, void *buf) |
58caa3dc DJ |
154 | { |
155 | struct i387_fsave *fp = (struct i387_fsave *) buf; | |
156 | int i; | |
3aee8918 | 157 | int st0_regnum = find_regno (regcache->tdesc, "st0"); |
cb197132 | 158 | unsigned long val2; |
58caa3dc DJ |
159 | |
160 | for (i = 0; i < 8; i++) | |
442ea881 PA |
161 | collect_register (regcache, i + st0_regnum, |
162 | ((char *) &fp->st_space[0]) + i * 10); | |
58caa3dc | 163 | |
cb197132 PA |
164 | fp->fioff = regcache_raw_get_unsigned_by_name (regcache, "fioff"); |
165 | fp->fooff = regcache_raw_get_unsigned_by_name (regcache, "fooff"); | |
166 | ||
58caa3dc | 167 | /* This one's 11 bits... */ |
cb197132 | 168 | val2 = regcache_raw_get_unsigned_by_name (regcache, "fop"); |
58caa3dc DJ |
169 | fp->fop = (val2 & 0x7FF) | (fp->fop & 0xF800); |
170 | ||
171 | /* Some registers are 16-bit. */ | |
cb197132 PA |
172 | fp->fctrl = regcache_raw_get_unsigned_by_name (regcache, "fctrl"); |
173 | fp->fstat = regcache_raw_get_unsigned_by_name (regcache, "fstat"); | |
174 | fp->ftag = regcache_raw_get_unsigned_by_name (regcache, "ftag"); | |
175 | fp->fiseg = regcache_raw_get_unsigned_by_name (regcache, "fiseg"); | |
176 | fp->foseg = regcache_raw_get_unsigned_by_name (regcache, "foseg"); | |
58caa3dc DJ |
177 | } |
178 | ||
179 | void | |
442ea881 | 180 | i387_fsave_to_cache (struct regcache *regcache, const void *buf) |
58caa3dc DJ |
181 | { |
182 | struct i387_fsave *fp = (struct i387_fsave *) buf; | |
183 | int i; | |
3aee8918 | 184 | int st0_regnum = find_regno (regcache->tdesc, "st0"); |
58caa3dc DJ |
185 | unsigned long val; |
186 | ||
187 | for (i = 0; i < 8; i++) | |
442ea881 PA |
188 | supply_register (regcache, i + st0_regnum, |
189 | ((char *) &fp->st_space[0]) + i * 10); | |
58caa3dc | 190 | |
442ea881 PA |
191 | supply_register_by_name (regcache, "fioff", &fp->fioff); |
192 | supply_register_by_name (regcache, "fooff", &fp->fooff); | |
1b3f6016 | 193 | |
58caa3dc DJ |
194 | /* Some registers are 16-bit. */ |
195 | val = fp->fctrl & 0xFFFF; | |
442ea881 | 196 | supply_register_by_name (regcache, "fctrl", &val); |
58caa3dc DJ |
197 | |
198 | val = fp->fstat & 0xFFFF; | |
442ea881 | 199 | supply_register_by_name (regcache, "fstat", &val); |
58caa3dc DJ |
200 | |
201 | val = fp->ftag & 0xFFFF; | |
442ea881 | 202 | supply_register_by_name (regcache, "ftag", &val); |
58caa3dc DJ |
203 | |
204 | val = fp->fiseg & 0xFFFF; | |
442ea881 | 205 | supply_register_by_name (regcache, "fiseg", &val); |
58caa3dc DJ |
206 | |
207 | val = fp->foseg & 0xFFFF; | |
442ea881 | 208 | supply_register_by_name (regcache, "foseg", &val); |
58caa3dc | 209 | |
0c2ead7e | 210 | /* fop has only 11 valid bits. */ |
58caa3dc | 211 | val = (fp->fop) & 0x7FF; |
442ea881 | 212 | supply_register_by_name (regcache, "fop", &val); |
58caa3dc DJ |
213 | } |
214 | ||
215 | void | |
442ea881 | 216 | i387_cache_to_fxsave (struct regcache *regcache, void *buf) |
58caa3dc DJ |
217 | { |
218 | struct i387_fxsave *fp = (struct i387_fxsave *) buf; | |
219 | int i; | |
3aee8918 PA |
220 | int st0_regnum = find_regno (regcache->tdesc, "st0"); |
221 | int xmm0_regnum = find_regno (regcache->tdesc, "xmm0"); | |
58caa3dc | 222 | unsigned long val, val2; |
3aee8918 PA |
223 | /* Amd64 has 16 xmm regs; I386 has 8 xmm regs. */ |
224 | int num_xmm_registers = register_size (regcache->tdesc, 0) == 8 ? 16 : 8; | |
58caa3dc DJ |
225 | |
226 | for (i = 0; i < 8; i++) | |
442ea881 PA |
227 | collect_register (regcache, i + st0_regnum, |
228 | ((char *) &fp->st_space[0]) + i * 16); | |
58caa3dc | 229 | for (i = 0; i < num_xmm_registers; i++) |
442ea881 PA |
230 | collect_register (regcache, i + xmm0_regnum, |
231 | ((char *) &fp->xmm_space[0]) + i * 16); | |
58caa3dc | 232 | |
cb197132 PA |
233 | fp->fioff = regcache_raw_get_unsigned_by_name (regcache, "fioff"); |
234 | fp->fooff = regcache_raw_get_unsigned_by_name (regcache, "fooff"); | |
235 | fp->mxcsr = regcache_raw_get_unsigned_by_name (regcache, "mxcsr"); | |
1b3f6016 | 236 | |
58caa3dc | 237 | /* This one's 11 bits... */ |
cb197132 | 238 | val2 = regcache_raw_get_unsigned_by_name (regcache, "fop"); |
58caa3dc DJ |
239 | fp->fop = (val2 & 0x7FF) | (fp->fop & 0xF800); |
240 | ||
241 | /* Some registers are 16-bit. */ | |
cb197132 PA |
242 | fp->fctrl = regcache_raw_get_unsigned_by_name (regcache, "fctrl"); |
243 | fp->fstat = regcache_raw_get_unsigned_by_name (regcache, "fstat"); | |
58caa3dc DJ |
244 | |
245 | /* Convert to the simplifed tag form stored in fxsave data. */ | |
cb197132 | 246 | val = regcache_raw_get_unsigned_by_name (regcache, "ftag"); |
73725ff3 | 247 | val2 = 0; |
58caa3dc DJ |
248 | for (i = 7; i >= 0; i--) |
249 | { | |
250 | int tag = (val >> (i * 2)) & 3; | |
251 | ||
252 | if (tag != 3) | |
253 | val2 |= (1 << i); | |
254 | } | |
0c2ead7e | 255 | fp->ftag = val2; |
58caa3dc | 256 | |
cb197132 PA |
257 | fp->fiseg = regcache_raw_get_unsigned_by_name (regcache, "fiseg"); |
258 | fp->foseg = regcache_raw_get_unsigned_by_name (regcache, "foseg"); | |
58caa3dc DJ |
259 | } |
260 | ||
1570b33e L |
261 | void |
262 | i387_cache_to_xsave (struct regcache *regcache, void *buf) | |
263 | { | |
264 | struct i387_xsave *fp = (struct i387_xsave *) buf; | |
2e187550 | 265 | bool amd64 = register_size (regcache->tdesc, 0) == 8; |
1570b33e L |
266 | int i; |
267 | unsigned long val, val2; | |
1570b33e | 268 | unsigned long long xstate_bv = 0; |
ff6527bb | 269 | unsigned long long clear_bv = 0; |
01f9f808 | 270 | char raw[64]; |
1f14ecbe | 271 | unsigned char *p; |
2e187550 | 272 | |
3aee8918 | 273 | /* Amd64 has 16 xmm regs; I386 has 8 xmm regs. */ |
2e187550 | 274 | int num_xmm_registers = amd64 ? 16 : 8; |
2e7b61ed JB |
275 | /* AVX512 adds 16 extra ZMM regs in Amd64 mode, but none in I386 mode.*/ |
276 | int num_zmm_high_registers = amd64 ? 16 : 0; | |
1570b33e | 277 | |
ff6527bb | 278 | /* The supported bits in `xstat_bv' are 8 bytes. Clear part in |
1570b33e L |
279 | vector registers if its bit in xstat_bv is zero. */ |
280 | clear_bv = (~fp->xstate_bv) & x86_xcr0; | |
281 | ||
282 | /* Clear part in x87 and vector registers if its bit in xstat_bv is | |
283 | zero. */ | |
284 | if (clear_bv) | |
285 | { | |
df7e5265 | 286 | if ((clear_bv & X86_XSTATE_X87)) |
8ee22052 AB |
287 | { |
288 | for (i = 0; i < 8; i++) | |
289 | memset (((char *) &fp->st_space[0]) + i * 16, 0, 10); | |
290 | ||
291 | fp->fioff = 0; | |
292 | fp->fooff = 0; | |
293 | fp->fctrl = I387_FCTRL_INIT_VAL; | |
294 | fp->fstat = 0; | |
295 | fp->ftag = 0; | |
296 | fp->fiseg = 0; | |
297 | fp->foseg = 0; | |
298 | fp->fop = 0; | |
299 | } | |
1570b33e | 300 | |
df7e5265 | 301 | if ((clear_bv & X86_XSTATE_SSE)) |
8ee22052 | 302 | for (i = 0; i < num_xmm_registers; i++) |
1570b33e L |
303 | memset (((char *) &fp->xmm_space[0]) + i * 16, 0, 16); |
304 | ||
df7e5265 | 305 | if ((clear_bv & X86_XSTATE_AVX)) |
8ee22052 | 306 | for (i = 0; i < num_xmm_registers; i++) |
1f14ecbe | 307 | memset (fp->ymmh_space () + i * 16, 0, 16); |
a196ebeb | 308 | |
8ee22052 AB |
309 | if ((clear_bv & X86_XSTATE_SSE) && (clear_bv & X86_XSTATE_AVX)) |
310 | memset (((char *) &fp->mxcsr), 0, 4); | |
311 | ||
df7e5265 | 312 | if ((clear_bv & X86_XSTATE_BNDREGS)) |
a196ebeb | 313 | for (i = 0; i < num_mpx_bnd_registers; i++) |
1f14ecbe | 314 | memset (fp->bndregs_space () + i * 16, 0, 16); |
a196ebeb | 315 | |
df7e5265 | 316 | if ((clear_bv & X86_XSTATE_BNDCFG)) |
a196ebeb | 317 | for (i = 0; i < num_mpx_cfg_registers; i++) |
1f14ecbe | 318 | memset (fp->bndcfg_space () + i * 8, 0, 8); |
01f9f808 | 319 | |
df7e5265 | 320 | if ((clear_bv & X86_XSTATE_K)) |
01f9f808 | 321 | for (i = 0; i < num_avx512_k_registers; i++) |
1f14ecbe | 322 | memset (fp->k_space () + i * 8, 0, 8); |
01f9f808 | 323 | |
df7e5265 | 324 | if ((clear_bv & X86_XSTATE_ZMM_H)) |
2e7b61ed | 325 | for (i = 0; i < num_xmm_registers; i++) |
1f14ecbe | 326 | memset (fp->zmmh_space () + i * 32, 0, 32); |
01f9f808 | 327 | |
df7e5265 | 328 | if ((clear_bv & X86_XSTATE_ZMM)) |
2e7b61ed JB |
329 | for (i = 0; i < num_zmm_high_registers; i++) |
330 | memset (fp->zmm16_space () + i * 64, 0, 64); | |
51547df6 MS |
331 | |
332 | if ((clear_bv & X86_XSTATE_PKRU)) | |
333 | for (i = 0; i < num_pkeys_registers; i++) | |
1f14ecbe | 334 | memset (fp->pkru_space () + i * 4, 0, 4); |
1570b33e L |
335 | } |
336 | ||
337 | /* Check if any x87 registers are changed. */ | |
df7e5265 | 338 | if ((x86_xcr0 & X86_XSTATE_X87)) |
1570b33e | 339 | { |
3aee8918 | 340 | int st0_regnum = find_regno (regcache->tdesc, "st0"); |
1570b33e L |
341 | |
342 | for (i = 0; i < 8; i++) | |
343 | { | |
344 | collect_register (regcache, i + st0_regnum, raw); | |
1f14ecbe | 345 | p = fp->st_space + i * 16; |
1570b33e L |
346 | if (memcmp (raw, p, 10)) |
347 | { | |
df7e5265 | 348 | xstate_bv |= X86_XSTATE_X87; |
1570b33e L |
349 | memcpy (p, raw, 10); |
350 | } | |
351 | } | |
352 | } | |
353 | ||
354 | /* Check if any SSE registers are changed. */ | |
df7e5265 | 355 | if ((x86_xcr0 & X86_XSTATE_SSE)) |
1570b33e | 356 | { |
3aee8918 | 357 | int xmm0_regnum = find_regno (regcache->tdesc, "xmm0"); |
1570b33e L |
358 | |
359 | for (i = 0; i < num_xmm_registers; i++) | |
360 | { | |
361 | collect_register (regcache, i + xmm0_regnum, raw); | |
1f14ecbe | 362 | p = fp->xmm_space + i * 16; |
1570b33e L |
363 | if (memcmp (raw, p, 16)) |
364 | { | |
df7e5265 | 365 | xstate_bv |= X86_XSTATE_SSE; |
1570b33e L |
366 | memcpy (p, raw, 16); |
367 | } | |
368 | } | |
369 | } | |
370 | ||
371 | /* Check if any AVX registers are changed. */ | |
df7e5265 | 372 | if ((x86_xcr0 & X86_XSTATE_AVX)) |
1570b33e | 373 | { |
3aee8918 | 374 | int ymm0h_regnum = find_regno (regcache->tdesc, "ymm0h"); |
1570b33e L |
375 | |
376 | for (i = 0; i < num_xmm_registers; i++) | |
377 | { | |
378 | collect_register (regcache, i + ymm0h_regnum, raw); | |
1f14ecbe | 379 | p = fp->ymmh_space () + i * 16; |
1570b33e L |
380 | if (memcmp (raw, p, 16)) |
381 | { | |
df7e5265 | 382 | xstate_bv |= X86_XSTATE_AVX; |
1570b33e L |
383 | memcpy (p, raw, 16); |
384 | } | |
385 | } | |
386 | } | |
387 | ||
a196ebeb | 388 | /* Check if any bound register has changed. */ |
df7e5265 | 389 | if ((x86_xcr0 & X86_XSTATE_BNDREGS)) |
a196ebeb WT |
390 | { |
391 | int bnd0r_regnum = find_regno (regcache->tdesc, "bnd0raw"); | |
392 | ||
393 | for (i = 0; i < num_mpx_bnd_registers; i++) | |
394 | { | |
395 | collect_register (regcache, i + bnd0r_regnum, raw); | |
1f14ecbe | 396 | p = fp->bndregs_space () + i * 16; |
a196ebeb WT |
397 | if (memcmp (raw, p, 16)) |
398 | { | |
df7e5265 | 399 | xstate_bv |= X86_XSTATE_BNDREGS; |
a196ebeb WT |
400 | memcpy (p, raw, 16); |
401 | } | |
402 | } | |
403 | } | |
404 | ||
405 | /* Check if any status register has changed. */ | |
df7e5265 | 406 | if ((x86_xcr0 & X86_XSTATE_BNDCFG)) |
a196ebeb WT |
407 | { |
408 | int bndcfg_regnum = find_regno (regcache->tdesc, "bndcfgu"); | |
409 | ||
410 | for (i = 0; i < num_mpx_cfg_registers; i++) | |
411 | { | |
412 | collect_register (regcache, i + bndcfg_regnum, raw); | |
1f14ecbe | 413 | p = fp->bndcfg_space () + i * 8; |
a196ebeb WT |
414 | if (memcmp (raw, p, 8)) |
415 | { | |
df7e5265 | 416 | xstate_bv |= X86_XSTATE_BNDCFG; |
a196ebeb WT |
417 | memcpy (p, raw, 8); |
418 | } | |
419 | } | |
420 | } | |
421 | ||
01f9f808 | 422 | /* Check if any K registers are changed. */ |
df7e5265 | 423 | if ((x86_xcr0 & X86_XSTATE_K)) |
01f9f808 MS |
424 | { |
425 | int k0_regnum = find_regno (regcache->tdesc, "k0"); | |
426 | ||
427 | for (i = 0; i < num_avx512_k_registers; i++) | |
428 | { | |
429 | collect_register (regcache, i + k0_regnum, raw); | |
1f14ecbe | 430 | p = fp->k_space () + i * 8; |
01f9f808 MS |
431 | if (memcmp (raw, p, 8) != 0) |
432 | { | |
df7e5265 | 433 | xstate_bv |= X86_XSTATE_K; |
01f9f808 MS |
434 | memcpy (p, raw, 8); |
435 | } | |
436 | } | |
437 | } | |
438 | ||
439 | /* Check if any of ZMM0H-ZMM15H registers are changed. */ | |
df7e5265 | 440 | if ((x86_xcr0 & X86_XSTATE_ZMM_H)) |
01f9f808 MS |
441 | { |
442 | int zmm0h_regnum = find_regno (regcache->tdesc, "zmm0h"); | |
443 | ||
2e7b61ed | 444 | for (i = 0; i < num_xmm_registers; i++) |
01f9f808 MS |
445 | { |
446 | collect_register (regcache, i + zmm0h_regnum, raw); | |
1f14ecbe | 447 | p = fp->zmmh_space () + i * 32; |
01f9f808 MS |
448 | if (memcmp (raw, p, 32) != 0) |
449 | { | |
df7e5265 | 450 | xstate_bv |= X86_XSTATE_ZMM_H; |
01f9f808 MS |
451 | memcpy (p, raw, 32); |
452 | } | |
453 | } | |
454 | } | |
455 | ||
2e7b61ed JB |
456 | /* Check if any of ZMM16-ZMM31 registers are changed. */ |
457 | if ((x86_xcr0 & X86_XSTATE_ZMM) && num_zmm_high_registers != 0) | |
01f9f808 | 458 | { |
2e7b61ed JB |
459 | int zmm16h_regnum = find_regno (regcache->tdesc, "zmm16h"); |
460 | int ymm16h_regnum = find_regno (regcache->tdesc, "ymm16h"); | |
461 | int xmm16_regnum = find_regno (regcache->tdesc, "xmm16"); | |
01f9f808 | 462 | |
2e7b61ed | 463 | for (i = 0; i < num_zmm_high_registers; i++) |
01f9f808 | 464 | { |
2e7b61ed JB |
465 | p = fp->zmm16_space () + i * 64; |
466 | ||
467 | /* ZMMH sub-register. */ | |
01f9f808 | 468 | collect_register (regcache, i + zmm16h_regnum, raw); |
2e7b61ed | 469 | if (memcmp (raw, p + 32, 32) != 0) |
01f9f808 | 470 | { |
df7e5265 | 471 | xstate_bv |= X86_XSTATE_ZMM; |
41770089 | 472 | memcpy (p + 32, raw, 32); |
01f9f808 | 473 | } |
01f9f808 | 474 | |
2e7b61ed JB |
475 | /* YMMH sub-register. */ |
476 | collect_register (regcache, i + ymm16h_regnum, raw); | |
477 | if (memcmp (raw, p + 16, 16) != 0) | |
01f9f808 | 478 | { |
df7e5265 | 479 | xstate_bv |= X86_XSTATE_ZMM; |
41770089 | 480 | memcpy (p + 16, raw, 16); |
01f9f808 | 481 | } |
01f9f808 | 482 | |
2e7b61ed JB |
483 | /* XMM sub-register. */ |
484 | collect_register (regcache, i + xmm16_regnum, raw); | |
01f9f808 MS |
485 | if (memcmp (raw, p, 16) != 0) |
486 | { | |
df7e5265 | 487 | xstate_bv |= X86_XSTATE_ZMM; |
01f9f808 MS |
488 | memcpy (p, raw, 16); |
489 | } | |
490 | } | |
491 | } | |
492 | ||
51547df6 MS |
493 | /* Check if any PKEYS registers are changed. */ |
494 | if ((x86_xcr0 & X86_XSTATE_PKRU)) | |
495 | { | |
496 | int pkru_regnum = find_regno (regcache->tdesc, "pkru"); | |
497 | ||
498 | for (i = 0; i < num_pkeys_registers; i++) | |
499 | { | |
500 | collect_register (regcache, i + pkru_regnum, raw); | |
1f14ecbe | 501 | p = fp->pkru_space () + i * 4; |
51547df6 MS |
502 | if (memcmp (raw, p, 4) != 0) |
503 | { | |
504 | xstate_bv |= X86_XSTATE_PKRU; | |
505 | memcpy (p, raw, 4); | |
506 | } | |
507 | } | |
508 | } | |
509 | ||
8ee22052 AB |
510 | if ((x86_xcr0 & X86_XSTATE_SSE) || (x86_xcr0 & X86_XSTATE_AVX)) |
511 | { | |
512 | collect_register_by_name (regcache, "mxcsr", raw); | |
513 | if (memcmp (raw, &fp->mxcsr, 4) != 0) | |
514 | { | |
515 | if (((fp->xstate_bv | xstate_bv) | |
516 | & (X86_XSTATE_SSE | X86_XSTATE_AVX)) == 0) | |
517 | xstate_bv |= X86_XSTATE_SSE; | |
518 | memcpy (&fp->mxcsr, raw, 4); | |
519 | } | |
520 | } | |
1570b33e | 521 | |
8ee22052 AB |
522 | if (x86_xcr0 & X86_XSTATE_X87) |
523 | { | |
524 | collect_register_by_name (regcache, "fioff", raw); | |
525 | if (memcmp (raw, &fp->fioff, 4) != 0) | |
526 | { | |
527 | xstate_bv |= X86_XSTATE_X87; | |
528 | memcpy (&fp->fioff, raw, 4); | |
529 | } | |
1570b33e | 530 | |
8ee22052 AB |
531 | collect_register_by_name (regcache, "fooff", raw); |
532 | if (memcmp (raw, &fp->fooff, 4) != 0) | |
533 | { | |
534 | xstate_bv |= X86_XSTATE_X87; | |
535 | memcpy (&fp->fooff, raw, 4); | |
536 | } | |
1570b33e | 537 | |
8ee22052 | 538 | /* This one's 11 bits... */ |
cb197132 | 539 | val2 = regcache_raw_get_unsigned_by_name (regcache, "fop"); |
8ee22052 AB |
540 | val2 = (val2 & 0x7FF) | (fp->fop & 0xF800); |
541 | if (fp->fop != val2) | |
542 | { | |
543 | xstate_bv |= X86_XSTATE_X87; | |
544 | fp->fop = val2; | |
545 | } | |
1570b33e | 546 | |
8ee22052 | 547 | /* Some registers are 16-bit. */ |
cb197132 | 548 | val = regcache_raw_get_unsigned_by_name (regcache, "fctrl"); |
8ee22052 AB |
549 | if (fp->fctrl != val) |
550 | { | |
551 | xstate_bv |= X86_XSTATE_X87; | |
552 | fp->fctrl = val; | |
553 | } | |
1570b33e | 554 | |
cb197132 | 555 | val = regcache_raw_get_unsigned_by_name (regcache, "fstat"); |
8ee22052 AB |
556 | if (fp->fstat != val) |
557 | { | |
558 | xstate_bv |= X86_XSTATE_X87; | |
559 | fp->fstat = val; | |
560 | } | |
1570b33e | 561 | |
8ee22052 | 562 | /* Convert to the simplifed tag form stored in fxsave data. */ |
cb197132 | 563 | val = regcache_raw_get_unsigned_by_name (regcache, "ftag"); |
8ee22052 AB |
564 | val2 = 0; |
565 | for (i = 7; i >= 0; i--) | |
566 | { | |
567 | int tag = (val >> (i * 2)) & 3; | |
1570b33e | 568 | |
8ee22052 AB |
569 | if (tag != 3) |
570 | val2 |= (1 << i); | |
571 | } | |
572 | if (fp->ftag != val2) | |
573 | { | |
574 | xstate_bv |= X86_XSTATE_X87; | |
575 | fp->ftag = val2; | |
576 | } | |
1570b33e | 577 | |
cb197132 | 578 | val = regcache_raw_get_unsigned_by_name (regcache, "fiseg"); |
8ee22052 AB |
579 | if (fp->fiseg != val) |
580 | { | |
581 | xstate_bv |= X86_XSTATE_X87; | |
582 | fp->fiseg = val; | |
583 | } | |
584 | ||
cb197132 | 585 | val = regcache_raw_get_unsigned_by_name (regcache, "foseg"); |
8ee22052 AB |
586 | if (fp->foseg != val) |
587 | { | |
588 | xstate_bv |= X86_XSTATE_X87; | |
589 | fp->foseg = val; | |
590 | } | |
591 | } | |
592 | ||
593 | /* Update the corresponding bits in xstate_bv if any SSE/AVX | |
594 | registers are changed. */ | |
595 | fp->xstate_bv |= xstate_bv; | |
1570b33e L |
596 | } |
597 | ||
58caa3dc DJ |
598 | static int |
599 | i387_ftag (struct i387_fxsave *fp, int regno) | |
600 | { | |
601 | unsigned char *raw = &fp->st_space[regno * 16]; | |
602 | unsigned int exponent; | |
603 | unsigned long fraction[2]; | |
604 | int integer; | |
605 | ||
606 | integer = raw[7] & 0x80; | |
607 | exponent = (((raw[9] & 0x7f) << 8) | raw[8]); | |
608 | fraction[0] = ((raw[3] << 24) | (raw[2] << 16) | (raw[1] << 8) | raw[0]); | |
609 | fraction[1] = (((raw[7] & 0x7f) << 24) | (raw[6] << 16) | |
1b3f6016 | 610 | | (raw[5] << 8) | raw[4]); |
58caa3dc DJ |
611 | |
612 | if (exponent == 0x7fff) | |
613 | { | |
614 | /* Special. */ | |
615 | return (2); | |
616 | } | |
617 | else if (exponent == 0x0000) | |
618 | { | |
619 | if (fraction[0] == 0x0000 && fraction[1] == 0x0000 && !integer) | |
1b3f6016 PA |
620 | { |
621 | /* Zero. */ | |
622 | return (1); | |
623 | } | |
58caa3dc | 624 | else |
1b3f6016 PA |
625 | { |
626 | /* Special. */ | |
627 | return (2); | |
628 | } | |
58caa3dc DJ |
629 | } |
630 | else | |
631 | { | |
632 | if (integer) | |
1b3f6016 PA |
633 | { |
634 | /* Valid. */ | |
635 | return (0); | |
636 | } | |
58caa3dc | 637 | else |
1b3f6016 PA |
638 | { |
639 | /* Special. */ | |
640 | return (2); | |
641 | } | |
58caa3dc DJ |
642 | } |
643 | } | |
644 | ||
645 | void | |
442ea881 | 646 | i387_fxsave_to_cache (struct regcache *regcache, const void *buf) |
58caa3dc DJ |
647 | { |
648 | struct i387_fxsave *fp = (struct i387_fxsave *) buf; | |
649 | int i, top; | |
3aee8918 PA |
650 | int st0_regnum = find_regno (regcache->tdesc, "st0"); |
651 | int xmm0_regnum = find_regno (regcache->tdesc, "xmm0"); | |
58caa3dc | 652 | unsigned long val; |
3aee8918 PA |
653 | /* Amd64 has 16 xmm regs; I386 has 8 xmm regs. */ |
654 | int num_xmm_registers = register_size (regcache->tdesc, 0) == 8 ? 16 : 8; | |
58caa3dc DJ |
655 | |
656 | for (i = 0; i < 8; i++) | |
442ea881 PA |
657 | supply_register (regcache, i + st0_regnum, |
658 | ((char *) &fp->st_space[0]) + i * 16); | |
58caa3dc | 659 | for (i = 0; i < num_xmm_registers; i++) |
442ea881 PA |
660 | supply_register (regcache, i + xmm0_regnum, |
661 | ((char *) &fp->xmm_space[0]) + i * 16); | |
58caa3dc | 662 | |
442ea881 PA |
663 | supply_register_by_name (regcache, "fioff", &fp->fioff); |
664 | supply_register_by_name (regcache, "fooff", &fp->fooff); | |
665 | supply_register_by_name (regcache, "mxcsr", &fp->mxcsr); | |
1b3f6016 | 666 | |
58caa3dc DJ |
667 | /* Some registers are 16-bit. */ |
668 | val = fp->fctrl & 0xFFFF; | |
442ea881 | 669 | supply_register_by_name (regcache, "fctrl", &val); |
58caa3dc DJ |
670 | |
671 | val = fp->fstat & 0xFFFF; | |
442ea881 | 672 | supply_register_by_name (regcache, "fstat", &val); |
58caa3dc DJ |
673 | |
674 | /* Generate the form of ftag data that GDB expects. */ | |
675 | top = (fp->fstat >> 11) & 0x7; | |
676 | val = 0; | |
677 | for (i = 7; i >= 0; i--) | |
678 | { | |
679 | int tag; | |
73725ff3 | 680 | if (fp->ftag & (1 << i)) |
58caa3dc DJ |
681 | tag = i387_ftag (fp, (i + 8 - top) % 8); |
682 | else | |
683 | tag = 3; | |
684 | val |= tag << (2 * i); | |
685 | } | |
442ea881 | 686 | supply_register_by_name (regcache, "ftag", &val); |
58caa3dc DJ |
687 | |
688 | val = fp->fiseg & 0xFFFF; | |
442ea881 | 689 | supply_register_by_name (regcache, "fiseg", &val); |
58caa3dc DJ |
690 | |
691 | val = fp->foseg & 0xFFFF; | |
442ea881 | 692 | supply_register_by_name (regcache, "foseg", &val); |
58caa3dc DJ |
693 | |
694 | val = (fp->fop) & 0x7FF; | |
442ea881 | 695 | supply_register_by_name (regcache, "fop", &val); |
58caa3dc | 696 | } |
1570b33e L |
697 | |
698 | void | |
699 | i387_xsave_to_cache (struct regcache *regcache, const void *buf) | |
700 | { | |
701 | struct i387_xsave *fp = (struct i387_xsave *) buf; | |
2e187550 | 702 | bool amd64 = register_size (regcache->tdesc, 0) == 8; |
1570b33e L |
703 | int i, top; |
704 | unsigned long val; | |
ff6527bb | 705 | unsigned long long clear_bv; |
1f14ecbe | 706 | unsigned char *p; |
2e187550 TV |
707 | |
708 | /* Amd64 has 16 xmm regs; I386 has 8 xmm regs. */ | |
709 | int num_xmm_registers = amd64 ? 16 : 8; | |
2e7b61ed JB |
710 | /* AVX512 adds 16 extra ZMM regs in Amd64 mode, but none in I386 mode.*/ |
711 | int num_zmm_high_registers = amd64 ? 16 : 0; | |
1570b33e | 712 | |
ff6527bb | 713 | /* The supported bits in `xstat_bv' are 8 bytes. Clear part in |
1570b33e L |
714 | vector registers if its bit in xstat_bv is zero. */ |
715 | clear_bv = (~fp->xstate_bv) & x86_xcr0; | |
716 | ||
717 | /* Check if any x87 registers are changed. */ | |
df7e5265 | 718 | if ((x86_xcr0 & X86_XSTATE_X87) != 0) |
1570b33e | 719 | { |
3aee8918 | 720 | int st0_regnum = find_regno (regcache->tdesc, "st0"); |
1570b33e | 721 | |
df7e5265 | 722 | if ((clear_bv & X86_XSTATE_X87) != 0) |
85724a0e PA |
723 | { |
724 | for (i = 0; i < 8; i++) | |
1c79eb8a | 725 | supply_register_zeroed (regcache, i + st0_regnum); |
85724a0e | 726 | } |
1570b33e | 727 | else |
1570b33e | 728 | { |
85724a0e PA |
729 | p = (gdb_byte *) &fp->st_space[0]; |
730 | for (i = 0; i < 8; i++) | |
731 | supply_register (regcache, i + st0_regnum, p + i * 16); | |
1570b33e L |
732 | } |
733 | } | |
734 | ||
df7e5265 | 735 | if ((x86_xcr0 & X86_XSTATE_SSE) != 0) |
1570b33e | 736 | { |
3aee8918 | 737 | int xmm0_regnum = find_regno (regcache->tdesc, "xmm0"); |
1570b33e | 738 | |
df7e5265 | 739 | if ((clear_bv & X86_XSTATE_SSE)) |
85724a0e PA |
740 | { |
741 | for (i = 0; i < num_xmm_registers; i++) | |
1c79eb8a | 742 | supply_register_zeroed (regcache, i + xmm0_regnum); |
85724a0e | 743 | } |
1570b33e | 744 | else |
1570b33e | 745 | { |
85724a0e PA |
746 | p = (gdb_byte *) &fp->xmm_space[0]; |
747 | for (i = 0; i < num_xmm_registers; i++) | |
748 | supply_register (regcache, i + xmm0_regnum, p + i * 16); | |
1570b33e L |
749 | } |
750 | } | |
751 | ||
df7e5265 | 752 | if ((x86_xcr0 & X86_XSTATE_AVX) != 0) |
1570b33e | 753 | { |
3aee8918 | 754 | int ymm0h_regnum = find_regno (regcache->tdesc, "ymm0h"); |
1570b33e | 755 | |
df7e5265 | 756 | if ((clear_bv & X86_XSTATE_AVX) != 0) |
85724a0e PA |
757 | { |
758 | for (i = 0; i < num_xmm_registers; i++) | |
1c79eb8a | 759 | supply_register_zeroed (regcache, i + ymm0h_regnum); |
85724a0e | 760 | } |
1570b33e | 761 | else |
1570b33e | 762 | { |
1f14ecbe | 763 | p = fp->ymmh_space (); |
85724a0e PA |
764 | for (i = 0; i < num_xmm_registers; i++) |
765 | supply_register (regcache, i + ymm0h_regnum, p + i * 16); | |
1570b33e L |
766 | } |
767 | } | |
768 | ||
df7e5265 | 769 | if ((x86_xcr0 & X86_XSTATE_BNDREGS)) |
a196ebeb WT |
770 | { |
771 | int bnd0r_regnum = find_regno (regcache->tdesc, "bnd0raw"); | |
772 | ||
773 | ||
df7e5265 | 774 | if ((clear_bv & X86_XSTATE_BNDREGS) != 0) |
a196ebeb WT |
775 | { |
776 | for (i = 0; i < num_mpx_bnd_registers; i++) | |
777 | supply_register_zeroed (regcache, i + bnd0r_regnum); | |
778 | } | |
779 | else | |
780 | { | |
1f14ecbe | 781 | p = fp->bndregs_space (); |
a196ebeb WT |
782 | for (i = 0; i < num_mpx_bnd_registers; i++) |
783 | supply_register (regcache, i + bnd0r_regnum, p + i * 16); | |
784 | } | |
785 | ||
786 | } | |
787 | ||
df7e5265 | 788 | if ((x86_xcr0 & X86_XSTATE_BNDCFG)) |
a196ebeb WT |
789 | { |
790 | int bndcfg_regnum = find_regno (regcache->tdesc, "bndcfgu"); | |
791 | ||
df7e5265 | 792 | if ((clear_bv & X86_XSTATE_BNDCFG) != 0) |
a196ebeb WT |
793 | { |
794 | for (i = 0; i < num_mpx_cfg_registers; i++) | |
795 | supply_register_zeroed (regcache, i + bndcfg_regnum); | |
796 | } | |
797 | else | |
798 | { | |
1f14ecbe | 799 | p = fp->bndcfg_space (); |
a196ebeb WT |
800 | for (i = 0; i < num_mpx_cfg_registers; i++) |
801 | supply_register (regcache, i + bndcfg_regnum, p + i * 8); | |
802 | } | |
803 | } | |
804 | ||
df7e5265 | 805 | if ((x86_xcr0 & X86_XSTATE_K) != 0) |
01f9f808 MS |
806 | { |
807 | int k0_regnum = find_regno (regcache->tdesc, "k0"); | |
808 | ||
df7e5265 | 809 | if ((clear_bv & X86_XSTATE_K) != 0) |
01f9f808 MS |
810 | { |
811 | for (i = 0; i < num_avx512_k_registers; i++) | |
812 | supply_register_zeroed (regcache, i + k0_regnum); | |
813 | } | |
814 | else | |
815 | { | |
1f14ecbe | 816 | p = fp->k_space (); |
01f9f808 MS |
817 | for (i = 0; i < num_avx512_k_registers; i++) |
818 | supply_register (regcache, i + k0_regnum, p + i * 8); | |
819 | } | |
820 | } | |
821 | ||
df7e5265 | 822 | if ((x86_xcr0 & X86_XSTATE_ZMM_H) != 0) |
01f9f808 MS |
823 | { |
824 | int zmm0h_regnum = find_regno (regcache->tdesc, "zmm0h"); | |
825 | ||
df7e5265 | 826 | if ((clear_bv & X86_XSTATE_ZMM_H) != 0) |
01f9f808 | 827 | { |
2e7b61ed | 828 | for (i = 0; i < num_xmm_registers; i++) |
01f9f808 MS |
829 | supply_register_zeroed (regcache, i + zmm0h_regnum); |
830 | } | |
831 | else | |
832 | { | |
1f14ecbe | 833 | p = fp->zmmh_space (); |
2e7b61ed | 834 | for (i = 0; i < num_xmm_registers; i++) |
01f9f808 MS |
835 | supply_register (regcache, i + zmm0h_regnum, p + i * 32); |
836 | } | |
837 | } | |
838 | ||
2e7b61ed | 839 | if ((x86_xcr0 & X86_XSTATE_ZMM) != 0 && num_zmm_high_registers != 0) |
01f9f808 | 840 | { |
2e7b61ed JB |
841 | int zmm16h_regnum = find_regno (regcache->tdesc, "zmm16h"); |
842 | int ymm16h_regnum = find_regno (regcache->tdesc, "ymm16h"); | |
843 | int xmm16_regnum = find_regno (regcache->tdesc, "xmm16"); | |
01f9f808 | 844 | |
df7e5265 | 845 | if ((clear_bv & X86_XSTATE_ZMM) != 0) |
01f9f808 | 846 | { |
2e7b61ed JB |
847 | for (i = 0; i < num_zmm_high_registers; i++) |
848 | { | |
849 | supply_register_zeroed (regcache, i + zmm16h_regnum); | |
850 | supply_register_zeroed (regcache, i + ymm16h_regnum); | |
851 | supply_register_zeroed (regcache, i + xmm16_regnum); | |
852 | } | |
01f9f808 MS |
853 | } |
854 | else | |
855 | { | |
1f14ecbe | 856 | p = fp->zmm16_space (); |
2e7b61ed JB |
857 | for (i = 0; i < num_zmm_high_registers; i++) |
858 | { | |
859 | supply_register (regcache, i + zmm16h_regnum, p + 32 + i * 64); | |
860 | supply_register (regcache, i + ymm16h_regnum, p + 16 + i * 64); | |
861 | supply_register (regcache, i + xmm16_regnum, p + i * 64); | |
862 | } | |
01f9f808 MS |
863 | } |
864 | } | |
865 | ||
51547df6 MS |
866 | if ((x86_xcr0 & X86_XSTATE_PKRU) != 0) |
867 | { | |
868 | int pkru_regnum = find_regno (regcache->tdesc, "pkru"); | |
869 | ||
870 | if ((clear_bv & X86_XSTATE_PKRU) != 0) | |
871 | { | |
872 | for (i = 0; i < num_pkeys_registers; i++) | |
873 | supply_register_zeroed (regcache, i + pkru_regnum); | |
874 | } | |
875 | else | |
876 | { | |
1f14ecbe | 877 | p = fp->pkru_space (); |
51547df6 MS |
878 | for (i = 0; i < num_pkeys_registers; i++) |
879 | supply_register (regcache, i + pkru_regnum, p + i * 4); | |
880 | } | |
881 | } | |
882 | ||
8ee22052 AB |
883 | if ((clear_bv & (X86_XSTATE_SSE | X86_XSTATE_AVX)) |
884 | == (X86_XSTATE_SSE | X86_XSTATE_AVX)) | |
885 | { | |
886 | unsigned int default_mxcsr = I387_MXCSR_INIT_VAL; | |
887 | supply_register_by_name (regcache, "mxcsr", &default_mxcsr); | |
888 | } | |
889 | else | |
890 | supply_register_by_name (regcache, "mxcsr", &fp->mxcsr); | |
1570b33e | 891 | |
8ee22052 AB |
892 | if ((clear_bv & X86_XSTATE_X87) != 0) |
893 | { | |
894 | supply_register_by_name_zeroed (regcache, "fioff"); | |
895 | supply_register_by_name_zeroed (regcache, "fooff"); | |
1570b33e | 896 | |
8ee22052 AB |
897 | val = I387_FCTRL_INIT_VAL; |
898 | supply_register_by_name (regcache, "fctrl", &val); | |
1570b33e | 899 | |
8ee22052 AB |
900 | supply_register_by_name_zeroed (regcache, "fstat"); |
901 | ||
902 | val = 0xFFFF; | |
903 | supply_register_by_name (regcache, "ftag", &val); | |
904 | ||
905 | supply_register_by_name_zeroed (regcache, "fiseg"); | |
906 | supply_register_by_name_zeroed (regcache, "foseg"); | |
907 | supply_register_by_name_zeroed (regcache, "fop"); | |
1570b33e | 908 | } |
8ee22052 AB |
909 | else |
910 | { | |
911 | supply_register_by_name (regcache, "fioff", &fp->fioff); | |
912 | supply_register_by_name (regcache, "fooff", &fp->fooff); | |
1570b33e | 913 | |
8ee22052 AB |
914 | /* Some registers are 16-bit. */ |
915 | val = fp->fctrl & 0xFFFF; | |
916 | supply_register_by_name (regcache, "fctrl", &val); | |
1570b33e | 917 | |
8ee22052 AB |
918 | val = fp->fstat & 0xFFFF; |
919 | supply_register_by_name (regcache, "fstat", &val); | |
1570b33e | 920 | |
8ee22052 AB |
921 | /* Generate the form of ftag data that GDB expects. */ |
922 | top = (fp->fstat >> 11) & 0x7; | |
923 | val = 0; | |
924 | for (i = 7; i >= 0; i--) | |
925 | { | |
926 | int tag; | |
927 | if (fp->ftag & (1 << i)) | |
c0c43317 | 928 | tag = i387_ftag (fp, (i + 8 - top) % 8); |
8ee22052 AB |
929 | else |
930 | tag = 3; | |
931 | val |= tag << (2 * i); | |
932 | } | |
933 | supply_register_by_name (regcache, "ftag", &val); | |
934 | ||
935 | val = fp->fiseg & 0xFFFF; | |
936 | supply_register_by_name (regcache, "fiseg", &val); | |
937 | ||
938 | val = fp->foseg & 0xFFFF; | |
939 | supply_register_by_name (regcache, "foseg", &val); | |
940 | ||
941 | val = (fp->fop) & 0x7FF; | |
942 | supply_register_by_name (regcache, "fop", &val); | |
943 | } | |
1570b33e L |
944 | } |
945 | ||
03e6fe7e JB |
946 | /* See i387-fp.h. */ |
947 | ||
948 | void | |
949 | i387_set_xsave_mask (uint64_t xcr0, int len) | |
950 | { | |
951 | x86_xcr0 = xcr0; | |
952 | xsave_layout = x86_fetch_xsave_layout (xcr0, len); | |
953 | } |