projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Remove some unnecessary focus switches
[deliverable/binutils-gdb.git] / gdb / i387-tdep.c
1 /* Intel 387 floating point stuff.
2
3 Copyright (C) 1988-2019 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 #include "defs.h"
21 #include "frame.h"
22 #include "gdbcore.h"
23 #include "inferior.h"
24 #include "language.h"
25 #include "regcache.h"
26 #include "target-float.h"
27 #include "value.h"
28
29 #include "i386-tdep.h"
30 #include "i387-tdep.h"
31 #include "gdbsupport/x86-xstate.h"
32
33 /* Print the floating point number specified by RAW. */
34
35 static void
36 print_i387_value (struct gdbarch *gdbarch,
37 const gdb_byte *raw, struct ui_file *file)
38 {
39 /* We try to print 19 digits. The last digit may or may not contain
40 garbage, but we'd better print one too many. We need enough room
41 to print the value, 1 position for the sign, 1 for the decimal
42 point, 19 for the digits and 6 for the exponent adds up to 27. */
43 const struct type *type = i387_ext_type (gdbarch);
44 std::string str = target_float_to_string (raw, type, " %-+27.19g");
45 fprintf_filtered (file, "%s", str.c_str ());
46 }
47
48 /* Print the classification for the register contents RAW. */
49
50 static void
51 print_i387_ext (struct gdbarch *gdbarch,
52 const gdb_byte *raw, struct ui_file *file)
53 {
54 int sign;
55 int integer;
56 unsigned int exponent;
57 unsigned long fraction[2];
58
59 sign = raw[9] & 0x80;
60 integer = raw[7] & 0x80;
61 exponent = (((raw[9] & 0x7f) << 8) | raw[8]);
62 fraction[0] = ((raw[3] << 24) | (raw[2] << 16) | (raw[1] << 8) | raw[0]);
63 fraction[1] = (((raw[7] & 0x7f) << 24) | (raw[6] << 16)
64 | (raw[5] << 8) | raw[4]);
65
66 if (exponent == 0x7fff && integer)
67 {
68 if (fraction[0] == 0x00000000 && fraction[1] == 0x00000000)
69 /* Infinity. */
70 fprintf_filtered (file, " %cInf", (sign ? '-' : '+'));
71 else if (sign && fraction[0] == 0x00000000 && fraction[1] == 0x40000000)
72 /* Real Indefinite (QNaN). */
73 fputs_unfiltered (" Real Indefinite (QNaN)", file);
74 else if (fraction[1] & 0x40000000)
75 /* QNaN. */
76 fputs_filtered (" QNaN", file);
77 else
78 /* SNaN. */
79 fputs_filtered (" SNaN", file);
80 }
81 else if (exponent < 0x7fff && exponent > 0x0000 && integer)
82 /* Normal. */
83 print_i387_value (gdbarch, raw, file);
84 else if (exponent == 0x0000)
85 {
86 /* Denormal or zero. */
87 print_i387_value (gdbarch, raw, file);
88
89 if (integer)
90 /* Pseudo-denormal. */
91 fputs_filtered (" Pseudo-denormal", file);
92 else if (fraction[0] || fraction[1])
93 /* Denormal. */
94 fputs_filtered (" Denormal", file);
95 }
96 else
97 /* Unsupported. */
98 fputs_filtered (" Unsupported", file);
99 }
100
101 /* Print the status word STATUS. If STATUS_P is false, then STATUS
102 was unavailable. */
103
104 static void
105 print_i387_status_word (int status_p,
106 unsigned int status, struct ui_file *file)
107 {
108 fprintf_filtered (file, "Status Word: ");
109 if (!status_p)
110 {
111 fprintf_filtered (file, "%s\n", _("<unavailable>"));
112 return;
113 }
114
115 fprintf_filtered (file, "%s", hex_string_custom (status, 4));
116 fputs_filtered (" ", file);
117 fprintf_filtered (file, " %s", (status & 0x0001) ? "IE" : " ");
118 fprintf_filtered (file, " %s", (status & 0x0002) ? "DE" : " ");
119 fprintf_filtered (file, " %s", (status & 0x0004) ? "ZE" : " ");
120 fprintf_filtered (file, " %s", (status & 0x0008) ? "OE" : " ");
121 fprintf_filtered (file, " %s", (status & 0x0010) ? "UE" : " ");
122 fprintf_filtered (file, " %s", (status & 0x0020) ? "PE" : " ");
123 fputs_filtered (" ", file);
124 fprintf_filtered (file, " %s", (status & 0x0080) ? "ES" : " ");
125 fputs_filtered (" ", file);
126 fprintf_filtered (file, " %s", (status & 0x0040) ? "SF" : " ");
127 fputs_filtered (" ", file);
128 fprintf_filtered (file, " %s", (status & 0x0100) ? "C0" : " ");
129 fprintf_filtered (file, " %s", (status & 0x0200) ? "C1" : " ");
130 fprintf_filtered (file, " %s", (status & 0x0400) ? "C2" : " ");
131 fprintf_filtered (file, " %s", (status & 0x4000) ? "C3" : " ");
132
133 fputs_filtered ("\n", file);
134
135 fprintf_filtered (file,
136 " TOP: %d\n", ((status >> 11) & 7));
137 }
138
139 /* Print the control word CONTROL. If CONTROL_P is false, then
140 CONTROL was unavailable. */
141
142 static void
143 print_i387_control_word (int control_p,
144 unsigned int control, struct ui_file *file)
145 {
146 fprintf_filtered (file, "Control Word: ");
147 if (!control_p)
148 {
149 fprintf_filtered (file, "%s\n", _("<unavailable>"));
150 return;
151 }
152
153 fprintf_filtered (file, "%s", hex_string_custom (control, 4));
154 fputs_filtered (" ", file);
155 fprintf_filtered (file, " %s", (control & 0x0001) ? "IM" : " ");
156 fprintf_filtered (file, " %s", (control & 0x0002) ? "DM" : " ");
157 fprintf_filtered (file, " %s", (control & 0x0004) ? "ZM" : " ");
158 fprintf_filtered (file, " %s", (control & 0x0008) ? "OM" : " ");
159 fprintf_filtered (file, " %s", (control & 0x0010) ? "UM" : " ");
160 fprintf_filtered (file, " %s", (control & 0x0020) ? "PM" : " ");
161
162 fputs_filtered ("\n", file);
163
164 fputs_filtered (" PC: ", file);
165 switch ((control >> 8) & 3)
166 {
167 case 0:
168 fputs_filtered ("Single Precision (24-bits)\n", file);
169 break;
170 case 1:
171 fputs_filtered ("Reserved\n", file);
172 break;
173 case 2:
174 fputs_filtered ("Double Precision (53-bits)\n", file);
175 break;
176 case 3:
177 fputs_filtered ("Extended Precision (64-bits)\n", file);
178 break;
179 }
180
181 fputs_filtered (" RC: ", file);
182 switch ((control >> 10) & 3)
183 {
184 case 0:
185 fputs_filtered ("Round to nearest\n", file);
186 break;
187 case 1:
188 fputs_filtered ("Round down\n", file);
189 break;
190 case 2:
191 fputs_filtered ("Round up\n", file);
192 break;
193 case 3:
194 fputs_filtered ("Round toward zero\n", file);
195 break;
196 }
197 }
198
199 /* Print out the i387 floating point state. Note that we ignore FRAME
200 in the code below. That's OK since floating-point registers are
201 never saved on the stack. */
202
203 void
204 i387_print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
205 struct frame_info *frame, const char *args)
206 {
207 struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (frame));
208 ULONGEST fctrl;
209 int fctrl_p;
210 ULONGEST fstat;
211 int fstat_p;
212 ULONGEST ftag;
213 int ftag_p;
214 ULONGEST fiseg;
215 int fiseg_p;
216 ULONGEST fioff;
217 int fioff_p;
218 ULONGEST foseg;
219 int foseg_p;
220 ULONGEST fooff;
221 int fooff_p;
222 ULONGEST fop;
223 int fop_p;
224 int fpreg;
225 int top;
226
227 gdb_assert (gdbarch == get_frame_arch (frame));
228
229 fctrl_p = read_frame_register_unsigned (frame,
230 I387_FCTRL_REGNUM (tdep), &fctrl);
231 fstat_p = read_frame_register_unsigned (frame,
232 I387_FSTAT_REGNUM (tdep), &fstat);
233 ftag_p = read_frame_register_unsigned (frame,
234 I387_FTAG_REGNUM (tdep), &ftag);
235 fiseg_p = read_frame_register_unsigned (frame,
236 I387_FISEG_REGNUM (tdep), &fiseg);
237 fioff_p = read_frame_register_unsigned (frame,
238 I387_FIOFF_REGNUM (tdep), &fioff);
239 foseg_p = read_frame_register_unsigned (frame,
240 I387_FOSEG_REGNUM (tdep), &foseg);
241 fooff_p = read_frame_register_unsigned (frame,
242 I387_FOOFF_REGNUM (tdep), &fooff);
243 fop_p = read_frame_register_unsigned (frame,
244 I387_FOP_REGNUM (tdep), &fop);
245
246 if (fstat_p)
247 {
248 top = ((fstat >> 11) & 7);
249
250 for (fpreg = 7; fpreg >= 0; fpreg--)
251 {
252 struct value *regval;
253 int regnum;
254 int i;
255 int tag = -1;
256
257 fprintf_filtered (file, "%sR%d: ", fpreg == top ? "=>" : " ", fpreg);
258
259 if (ftag_p)
260 {
261 tag = (ftag >> (fpreg * 2)) & 3;
262
263 switch (tag)
264 {
265 case 0:
266 fputs_filtered ("Valid ", file);
267 break;
268 case 1:
269 fputs_filtered ("Zero ", file);
270 break;
271 case 2:
272 fputs_filtered ("Special ", file);
273 break;
274 case 3:
275 fputs_filtered ("Empty ", file);
276 break;
277 }
278 }
279 else
280 fputs_filtered ("Unknown ", file);
281
282 regnum = (fpreg + 8 - top) % 8 + I387_ST0_REGNUM (tdep);
283 regval = get_frame_register_value (frame, regnum);
284
285 if (value_entirely_available (regval))
286 {
287 const gdb_byte *raw = value_contents (regval);
288
289 fputs_filtered ("0x", file);
290 for (i = 9; i >= 0; i--)
291 fprintf_filtered (file, "%02x", raw[i]);
292
293 if (tag != -1 && tag != 3)
294 print_i387_ext (gdbarch, raw, file);
295 }
296 else
297 fprintf_filtered (file, "%s", _("<unavailable>"));
298
299 fputs_filtered ("\n", file);
300 }
301 }
302
303 fputs_filtered ("\n", file);
304 print_i387_status_word (fstat_p, fstat, file);
305 print_i387_control_word (fctrl_p, fctrl, file);
306 fprintf_filtered (file, "Tag Word: %s\n",
307 ftag_p ? hex_string_custom (ftag, 4) : _("<unavailable>"));
308 fprintf_filtered (file, "Instruction Pointer: %s:",
309 fiseg_p ? hex_string_custom (fiseg, 2) : _("<unavailable>"));
310 fprintf_filtered (file, "%s\n",
311 fioff_p ? hex_string_custom (fioff, 8) : _("<unavailable>"));
312 fprintf_filtered (file, "Operand Pointer: %s:",
313 foseg_p ? hex_string_custom (foseg, 2) : _("<unavailable>"));
314 fprintf_filtered (file, "%s\n",
315 fooff_p ? hex_string_custom (fooff, 8) : _("<unavailable>"));
316 fprintf_filtered (file, "Opcode: %s\n",
317 fop_p
318 ? (hex_string_custom (fop ? (fop | 0xd800) : 0, 4))
319 : _("<unavailable>"));
320 }
321 \f
322
323 /* Return nonzero if a value of type TYPE stored in register REGNUM
324 needs any special handling. */
325
326 int
327 i387_convert_register_p (struct gdbarch *gdbarch, int regnum,
328 struct type *type)
329 {
330 if (i386_fp_regnum_p (gdbarch, regnum))
331 {
332 /* Floating point registers must be converted unless we are
333 accessing them in their hardware type or TYPE is not float. */
334 if (type == i387_ext_type (gdbarch)
335 || TYPE_CODE (type) != TYPE_CODE_FLT)
336 return 0;
337 else
338 return 1;
339 }
340
341 return 0;
342 }
343
344 /* Read a value of type TYPE from register REGNUM in frame FRAME, and
345 return its contents in TO. */
346
347 int
348 i387_register_to_value (struct frame_info *frame, int regnum,
349 struct type *type, gdb_byte *to,
350 int *optimizedp, int *unavailablep)
351 {
352 struct gdbarch *gdbarch = get_frame_arch (frame);
353 gdb_byte from[I386_MAX_REGISTER_SIZE];
354
355 gdb_assert (i386_fp_regnum_p (gdbarch, regnum));
356
357 /* We only support floating-point values. */
358 if (TYPE_CODE (type) != TYPE_CODE_FLT)
359 {
360 warning (_("Cannot convert floating-point register value "
361 "to non-floating-point type."));
362 *optimizedp = *unavailablep = 0;
363 return 0;
364 }
365
366 /* Convert to TYPE. */
367 if (!get_frame_register_bytes (frame, regnum, 0,
368 register_size (gdbarch, regnum),
369 from, optimizedp, unavailablep))
370 return 0;
371
372 target_float_convert (from, i387_ext_type (gdbarch), to, type);
373 *optimizedp = *unavailablep = 0;
374 return 1;
375 }
376
377 /* Write the contents FROM of a value of type TYPE into register
378 REGNUM in frame FRAME. */
379
380 void
381 i387_value_to_register (struct frame_info *frame, int regnum,
382 struct type *type, const gdb_byte *from)
383 {
384 struct gdbarch *gdbarch = get_frame_arch (frame);
385 gdb_byte to[I386_MAX_REGISTER_SIZE];
386
387 gdb_assert (i386_fp_regnum_p (gdbarch, regnum));
388
389 /* We only support floating-point values. */
390 if (TYPE_CODE (type) != TYPE_CODE_FLT)
391 {
392 warning (_("Cannot convert non-floating-point type "
393 "to floating-point register value."));
394 return;
395 }
396
397 /* Convert from TYPE. */
398 target_float_convert (from, type, to, i387_ext_type (gdbarch));
399 put_frame_register (frame, regnum, to);
400 }
401 \f
402
403 /* Handle FSAVE and FXSAVE formats. */
404
405 /* At fsave_offset[REGNUM] you'll find the offset to the location in
406 the data structure used by the "fsave" instruction where GDB
407 register REGNUM is stored. */
408
409 static int fsave_offset[] =
410 {
411 28 + 0 * 10, /* %st(0) ... */
412 28 + 1 * 10,
413 28 + 2 * 10,
414 28 + 3 * 10,
415 28 + 4 * 10,
416 28 + 5 * 10,
417 28 + 6 * 10,
418 28 + 7 * 10, /* ... %st(7). */
419 0, /* `fctrl' (16 bits). */
420 4, /* `fstat' (16 bits). */
421 8, /* `ftag' (16 bits). */
422 16, /* `fiseg' (16 bits). */
423 12, /* `fioff'. */
424 24, /* `foseg' (16 bits). */
425 20, /* `fooff'. */
426 18 /* `fop' (bottom 11 bits). */
427 };
428
429 #define FSAVE_ADDR(tdep, fsave, regnum) \
430 (fsave + fsave_offset[regnum - I387_ST0_REGNUM (tdep)])
431 \f
432
433 /* Fill register REGNUM in REGCACHE with the appropriate value from
434 *FSAVE. This function masks off any of the reserved bits in
435 *FSAVE. */
436
437 void
438 i387_supply_fsave (struct regcache *regcache, int regnum, const void *fsave)
439 {
440 struct gdbarch *gdbarch = regcache->arch ();
441 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
442 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
443 const gdb_byte *regs = (const gdb_byte *) fsave;
444 int i;
445
446 gdb_assert (tdep->st0_regnum >= I386_ST0_REGNUM);
447
448 for (i = I387_ST0_REGNUM (tdep); i < I387_XMM0_REGNUM (tdep); i++)
449 if (regnum == -1 || regnum == i)
450 {
451 if (fsave == NULL)
452 {
453 regcache->raw_supply (i, NULL);
454 continue;
455 }
456
457 /* Most of the FPU control registers occupy only 16 bits in the
458 fsave area. Give those a special treatment. */
459 if (i >= I387_FCTRL_REGNUM (tdep)
460 && i != I387_FIOFF_REGNUM (tdep) && i != I387_FOOFF_REGNUM (tdep))
461 {
462 gdb_byte val[4];
463
464 memcpy (val, FSAVE_ADDR (tdep, regs, i), 2);
465 val[2] = val[3] = 0;
466 if (i == I387_FOP_REGNUM (tdep))
467 val[1] &= ((1 << 3) - 1);
468 regcache->raw_supply (i, val);
469 }
470 else
471 regcache->raw_supply (i, FSAVE_ADDR (tdep, regs, i));
472 }
473
474 /* Provide dummy values for the SSE registers. */
475 for (i = I387_XMM0_REGNUM (tdep); i < I387_MXCSR_REGNUM (tdep); i++)
476 if (regnum == -1 || regnum == i)
477 regcache->raw_supply (i, NULL);
478 if (regnum == -1 || regnum == I387_MXCSR_REGNUM (tdep))
479 {
480 gdb_byte buf[4];
481
482 store_unsigned_integer (buf, 4, byte_order, I387_MXCSR_INIT_VAL);
483 regcache->raw_supply (I387_MXCSR_REGNUM (tdep), buf);
484 }
485 }
486
487 /* Fill register REGNUM (if it is a floating-point register) in *FSAVE
488 with the value from REGCACHE. If REGNUM is -1, do this for all
489 registers. This function doesn't touch any of the reserved bits in
490 *FSAVE. */
491
492 void
493 i387_collect_fsave (const struct regcache *regcache, int regnum, void *fsave)
494 {
495 struct gdbarch_tdep *tdep = gdbarch_tdep (regcache->arch ());
496 gdb_byte *regs = (gdb_byte *) fsave;
497 int i;
498
499 gdb_assert (tdep->st0_regnum >= I386_ST0_REGNUM);
500
501 for (i = I387_ST0_REGNUM (tdep); i < I387_XMM0_REGNUM (tdep); i++)
502 if (regnum == -1 || regnum == i)
503 {
504 /* Most of the FPU control registers occupy only 16 bits in
505 the fsave area. Give those a special treatment. */
506 if (i >= I387_FCTRL_REGNUM (tdep)
507 && i != I387_FIOFF_REGNUM (tdep) && i != I387_FOOFF_REGNUM (tdep))
508 {
509 gdb_byte buf[4];
510
511 regcache->raw_collect (i, buf);
512
513 if (i == I387_FOP_REGNUM (tdep))
514 {
515 /* The opcode occupies only 11 bits. Make sure we
516 don't touch the other bits. */
517 buf[1] &= ((1 << 3) - 1);
518 buf[1] |= ((FSAVE_ADDR (tdep, regs, i))[1] & ~((1 << 3) - 1));
519 }
520 memcpy (FSAVE_ADDR (tdep, regs, i), buf, 2);
521 }
522 else
523 regcache->raw_collect (i, FSAVE_ADDR (tdep, regs, i));
524 }
525 }
526 \f
527
528 /* At fxsave_offset[REGNUM] you'll find the offset to the location in
529 the data structure used by the "fxsave" instruction where GDB
530 register REGNUM is stored. */
531
532 static int fxsave_offset[] =
533 {
534 32, /* %st(0) through ... */
535 48,
536 64,
537 80,
538 96,
539 112,
540 128,
541 144, /* ... %st(7) (80 bits each). */
542 0, /* `fctrl' (16 bits). */
543 2, /* `fstat' (16 bits). */
544 4, /* `ftag' (16 bits). */
545 12, /* `fiseg' (16 bits). */
546 8, /* `fioff'. */
547 20, /* `foseg' (16 bits). */
548 16, /* `fooff'. */
549 6, /* `fop' (bottom 11 bits). */
550 160 + 0 * 16, /* %xmm0 through ... */
551 160 + 1 * 16,
552 160 + 2 * 16,
553 160 + 3 * 16,
554 160 + 4 * 16,
555 160 + 5 * 16,
556 160 + 6 * 16,
557 160 + 7 * 16,
558 160 + 8 * 16,
559 160 + 9 * 16,
560 160 + 10 * 16,
561 160 + 11 * 16,
562 160 + 12 * 16,
563 160 + 13 * 16,
564 160 + 14 * 16,
565 160 + 15 * 16, /* ... %xmm15 (128 bits each). */
566 };
567
568 #define FXSAVE_ADDR(tdep, fxsave, regnum) \
569 (fxsave + fxsave_offset[regnum - I387_ST0_REGNUM (tdep)])
570
571 /* We made an unfortunate choice in putting %mxcsr after the SSE
572 registers %xmm0-%xmm7 instead of before, since it makes supporting
573 the registers %xmm8-%xmm15 on AMD64 a bit involved. Therefore we
574 don't include the offset for %mxcsr here above. */
575
576 #define FXSAVE_MXCSR_ADDR(fxsave) (fxsave + 24)
577
578 static int i387_tag (const gdb_byte *raw);
579 \f
580
581 /* Fill register REGNUM in REGCACHE with the appropriate
582 floating-point or SSE register value from *FXSAVE. This function
583 masks off any of the reserved bits in *FXSAVE. */
584
585 void
586 i387_supply_fxsave (struct regcache *regcache, int regnum, const void *fxsave)
587 {
588 struct gdbarch_tdep *tdep = gdbarch_tdep (regcache->arch ());
589 const gdb_byte *regs = (const gdb_byte *) fxsave;
590 int i;
591
592 gdb_assert (tdep->st0_regnum >= I386_ST0_REGNUM);
593 gdb_assert (tdep->num_xmm_regs > 0);
594
595 for (i = I387_ST0_REGNUM (tdep); i < I387_MXCSR_REGNUM (tdep); i++)
596 if (regnum == -1 || regnum == i)
597 {
598 if (regs == NULL)
599 {
600 regcache->raw_supply (i, NULL);
601 continue;
602 }
603
604 /* Most of the FPU control registers occupy only 16 bits in
605 the fxsave area. Give those a special treatment. */
606 if (i >= I387_FCTRL_REGNUM (tdep) && i < I387_XMM0_REGNUM (tdep)
607 && i != I387_FIOFF_REGNUM (tdep) && i != I387_FOOFF_REGNUM (tdep))
608 {
609 gdb_byte val[4];
610
611 memcpy (val, FXSAVE_ADDR (tdep, regs, i), 2);
612 val[2] = val[3] = 0;
613 if (i == I387_FOP_REGNUM (tdep))
614 val[1] &= ((1 << 3) - 1);
615 else if (i== I387_FTAG_REGNUM (tdep))
616 {
617 /* The fxsave area contains a simplified version of
618 the tag word. We have to look at the actual 80-bit
619 FP data to recreate the traditional i387 tag word. */
620
621 unsigned long ftag = 0;
622 int fpreg;
623 int top;
624
625 top = ((FXSAVE_ADDR (tdep, regs,
626 I387_FSTAT_REGNUM (tdep)))[1] >> 3);
627 top &= 0x7;
628
629 for (fpreg = 7; fpreg >= 0; fpreg--)
630 {
631 int tag;
632
633 if (val[0] & (1 << fpreg))
634 {
635 int thisreg = (fpreg + 8 - top) % 8
636 + I387_ST0_REGNUM (tdep);
637 tag = i387_tag (FXSAVE_ADDR (tdep, regs, thisreg));
638 }
639 else
640 tag = 3; /* Empty */
641
642 ftag |= tag << (2 * fpreg);
643 }
644 val[0] = ftag & 0xff;
645 val[1] = (ftag >> 8) & 0xff;
646 }
647 regcache->raw_supply (i, val);
648 }
649 else
650 regcache->raw_supply (i, FXSAVE_ADDR (tdep, regs, i));
651 }
652
653 if (regnum == I387_MXCSR_REGNUM (tdep) || regnum == -1)
654 {
655 if (regs == NULL)
656 regcache->raw_supply (I387_MXCSR_REGNUM (tdep), NULL);
657 else
658 regcache->raw_supply (I387_MXCSR_REGNUM (tdep),
659 FXSAVE_MXCSR_ADDR (regs));
660 }
661 }
662
663 /* Fill register REGNUM (if it is a floating-point or SSE register) in
664 *FXSAVE with the value from REGCACHE. If REGNUM is -1, do this for
665 all registers. This function doesn't touch any of the reserved
666 bits in *FXSAVE. */
667
668 void
669 i387_collect_fxsave (const struct regcache *regcache, int regnum, void *fxsave)
670 {
671 struct gdbarch_tdep *tdep = gdbarch_tdep (regcache->arch ());
672 gdb_byte *regs = (gdb_byte *) fxsave;
673 int i;
674
675 gdb_assert (tdep->st0_regnum >= I386_ST0_REGNUM);
676 gdb_assert (tdep->num_xmm_regs > 0);
677
678 for (i = I387_ST0_REGNUM (tdep); i < I387_MXCSR_REGNUM (tdep); i++)
679 if (regnum == -1 || regnum == i)
680 {
681 /* Most of the FPU control registers occupy only 16 bits in
682 the fxsave area. Give those a special treatment. */
683 if (i >= I387_FCTRL_REGNUM (tdep) && i < I387_XMM0_REGNUM (tdep)
684 && i != I387_FIOFF_REGNUM (tdep) && i != I387_FOOFF_REGNUM (tdep))
685 {
686 gdb_byte buf[4];
687
688 regcache->raw_collect (i, buf);
689
690 if (i == I387_FOP_REGNUM (tdep))
691 {
692 /* The opcode occupies only 11 bits. Make sure we
693 don't touch the other bits. */
694 buf[1] &= ((1 << 3) - 1);
695 buf[1] |= ((FXSAVE_ADDR (tdep, regs, i))[1] & ~((1 << 3) - 1));
696 }
697 else if (i == I387_FTAG_REGNUM (tdep))
698 {
699 /* Converting back is much easier. */
700
701 unsigned short ftag;
702 int fpreg;
703
704 ftag = (buf[1] << 8) | buf[0];
705 buf[0] = 0;
706 buf[1] = 0;
707
708 for (fpreg = 7; fpreg >= 0; fpreg--)
709 {
710 int tag = (ftag >> (fpreg * 2)) & 3;
711
712 if (tag != 3)
713 buf[0] |= (1 << fpreg);
714 }
715 }
716 memcpy (FXSAVE_ADDR (tdep, regs, i), buf, 2);
717 }
718 else
719 regcache->raw_collect (i, FXSAVE_ADDR (tdep, regs, i));
720 }
721
722 if (regnum == I387_MXCSR_REGNUM (tdep) || regnum == -1)
723 regcache->raw_collect (I387_MXCSR_REGNUM (tdep),
724 FXSAVE_MXCSR_ADDR (regs));
725 }
726
727 /* `xstate_bv' is at byte offset 512. */
728 #define XSAVE_XSTATE_BV_ADDR(xsave) (xsave + 512)
729
730 /* At xsave_avxh_offset[REGNUM] you'll find the offset to the location in
731 the upper 128bit of AVX register data structure used by the "xsave"
732 instruction where GDB register REGNUM is stored. */
733
734 static int xsave_avxh_offset[] =
735 {
736 576 + 0 * 16, /* Upper 128bit of %ymm0 through ... */
737 576 + 1 * 16,
738 576 + 2 * 16,
739 576 + 3 * 16,
740 576 + 4 * 16,
741 576 + 5 * 16,
742 576 + 6 * 16,
743 576 + 7 * 16,
744 576 + 8 * 16,
745 576 + 9 * 16,
746 576 + 10 * 16,
747 576 + 11 * 16,
748 576 + 12 * 16,
749 576 + 13 * 16,
750 576 + 14 * 16,
751 576 + 15 * 16 /* Upper 128bit of ... %ymm15 (128 bits each). */
752 };
753
754 #define XSAVE_AVXH_ADDR(tdep, xsave, regnum) \
755 (xsave + xsave_avxh_offset[regnum - I387_YMM0H_REGNUM (tdep)])
756
757 /* At xsave_ymm_avx512_offset[REGNUM] you'll find the offset to the location in
758 the upper 128bit of ZMM register data structure used by the "xsave"
759 instruction where GDB register REGNUM is stored. */
760
761 static int xsave_ymm_avx512_offset[] =
762 {
763 /* HI16_ZMM_area + 16 bytes + regnum* 64 bytes. */
764 1664 + 16 + 0 * 64, /* %ymm16 through... */
765 1664 + 16 + 1 * 64,
766 1664 + 16 + 2 * 64,
767 1664 + 16 + 3 * 64,
768 1664 + 16 + 4 * 64,
769 1664 + 16 + 5 * 64,
770 1664 + 16 + 6 * 64,
771 1664 + 16 + 7 * 64,
772 1664 + 16 + 8 * 64,
773 1664 + 16 + 9 * 64,
774 1664 + 16 + 10 * 64,
775 1664 + 16 + 11 * 64,
776 1664 + 16 + 12 * 64,
777 1664 + 16 + 13 * 64,
778 1664 + 16 + 14 * 64,
779 1664 + 16 + 15 * 64 /* ... %ymm31 (128 bits each). */
780 };
781
782 #define XSAVE_YMM_AVX512_ADDR(tdep, xsave, regnum) \
783 (xsave + xsave_ymm_avx512_offset[regnum - I387_YMM16H_REGNUM (tdep)])
784
785 static int xsave_xmm_avx512_offset[] =
786 {
787 1664 + 0 * 64, /* %ymm16 through... */
788 1664 + 1 * 64,
789 1664 + 2 * 64,
790 1664 + 3 * 64,
791 1664 + 4 * 64,
792 1664 + 5 * 64,
793 1664 + 6 * 64,
794 1664 + 7 * 64,
795 1664 + 8 * 64,
796 1664 + 9 * 64,
797 1664 + 10 * 64,
798 1664 + 11 * 64,
799 1664 + 12 * 64,
800 1664 + 13 * 64,
801 1664 + 14 * 64,
802 1664 + 15 * 64 /* ... %ymm31 (128 bits each). */
803 };
804
805 #define XSAVE_XMM_AVX512_ADDR(tdep, xsave, regnum) \
806 (xsave + xsave_xmm_avx512_offset[regnum - I387_XMM16_REGNUM (tdep)])
807
808 static int xsave_mpx_offset[] = {
809 960 + 0 * 16, /* bnd0r...bnd3r registers. */
810 960 + 1 * 16,
811 960 + 2 * 16,
812 960 + 3 * 16,
813 1024 + 0 * 8, /* bndcfg ... bndstatus. */
814 1024 + 1 * 8,
815 };
816
817 #define XSAVE_MPX_ADDR(tdep, xsave, regnum) \
818 (xsave + xsave_mpx_offset[regnum - I387_BND0R_REGNUM (tdep)])
819
820 /* At xsave_avx512__h_offset[REGNUM] you find the offset to the location
821 of the AVX512 opmask register data structure used by the "xsave"
822 instruction where GDB register REGNUM is stored. */
823
824 static int xsave_avx512_k_offset[] =
825 {
826 1088 + 0 * 8, /* %k0 through... */
827 1088 + 1 * 8,
828 1088 + 2 * 8,
829 1088 + 3 * 8,
830 1088 + 4 * 8,
831 1088 + 5 * 8,
832 1088 + 6 * 8,
833 1088 + 7 * 8 /* %k7 (64 bits each). */
834 };
835
836 #define XSAVE_AVX512_K_ADDR(tdep, xsave, regnum) \
837 (xsave + xsave_avx512_k_offset[regnum - I387_K0_REGNUM (tdep)])
838
839 /* At xsave_avx512_zmm_h_offset[REGNUM] you find the offset to the location in
840 the upper 256bit of AVX512 ZMMH register data structure used by the "xsave"
841 instruction where GDB register REGNUM is stored. */
842
843 static int xsave_avx512_zmm_h_offset[] =
844 {
845 1152 + 0 * 32,
846 1152 + 1 * 32, /* Upper 256bit of %zmmh0 through... */
847 1152 + 2 * 32,
848 1152 + 3 * 32,
849 1152 + 4 * 32,
850 1152 + 5 * 32,
851 1152 + 6 * 32,
852 1152 + 7 * 32,
853 1152 + 8 * 32,
854 1152 + 9 * 32,
855 1152 + 10 * 32,
856 1152 + 11 * 32,
857 1152 + 12 * 32,
858 1152 + 13 * 32,
859 1152 + 14 * 32,
860 1152 + 15 * 32, /* Upper 256bit of... %zmmh15 (256 bits each). */
861 1664 + 32 + 0 * 64, /* Upper 256bit of... %zmmh16 (256 bits each). */
862 1664 + 32 + 1 * 64,
863 1664 + 32 + 2 * 64,
864 1664 + 32 + 3 * 64,
865 1664 + 32 + 4 * 64,
866 1664 + 32 + 5 * 64,
867 1664 + 32 + 6 * 64,
868 1664 + 32 + 7 * 64,
869 1664 + 32 + 8 * 64,
870 1664 + 32 + 9 * 64,
871 1664 + 32 + 10 * 64,
872 1664 + 32 + 11 * 64,
873 1664 + 32 + 12 * 64,
874 1664 + 32 + 13 * 64,
875 1664 + 32 + 14 * 64,
876 1664 + 32 + 15 * 64 /* Upper 256bit of... %zmmh31 (256 bits each). */
877 };
878
879 #define XSAVE_AVX512_ZMM_H_ADDR(tdep, xsave, regnum) \
880 (xsave + xsave_avx512_zmm_h_offset[regnum - I387_ZMM0H_REGNUM (tdep)])
881
882 /* At xsave_pkeys_offset[REGNUM] you find the offset to the location
883 of the PKRU register data structure used by the "xsave"
884 instruction where GDB register REGNUM is stored. */
885
886 static int xsave_pkeys_offset[] =
887 {
888 2688 + 0 * 8 /* %pkru (64 bits in XSTATE, 32-bit actually used by
889 instructions and applications). */
890 };
891
892 #define XSAVE_PKEYS_ADDR(tdep, xsave, regnum) \
893 (xsave + xsave_pkeys_offset[regnum - I387_PKRU_REGNUM (tdep)])
894
895
896 /* Extract from XSAVE a bitset of the features that are available on the
897 target, but which have not yet been enabled. */
898
899 ULONGEST
900 i387_xsave_get_clear_bv (struct gdbarch *gdbarch, const void *xsave)
901 {
902 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
903 const gdb_byte *regs = (const gdb_byte *) xsave;
904 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
905
906 /* Get `xstat_bv'. The supported bits in `xstat_bv' are 8 bytes. */
907 ULONGEST xstate_bv = extract_unsigned_integer (XSAVE_XSTATE_BV_ADDR (regs),
908 8, byte_order);
909
910 /* Clear part in vector registers if its bit in xstat_bv is zero. */
911 ULONGEST clear_bv = (~(xstate_bv)) & tdep->xcr0;
912
913 return clear_bv;
914 }
915
916 /* Similar to i387_supply_fxsave, but use XSAVE extended state. */
917
918 void
919 i387_supply_xsave (struct regcache *regcache, int regnum,
920 const void *xsave)
921 {
922 struct gdbarch *gdbarch = regcache->arch ();
923 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
924 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
925 const gdb_byte *regs = (const gdb_byte *) xsave;
926 int i;
927 /* In 64-bit mode the split between "low" and "high" ZMM registers is at
928 ZMM16. Outside of 64-bit mode there are no "high" ZMM registers at all.
929 Precalculate the number to be used for the split point, with the all
930 registers in the "low" portion outside of 64-bit mode. */
931 unsigned int zmm_endlo_regnum = I387_ZMM0H_REGNUM (tdep)
932 + std::min (tdep->num_zmm_regs, 16);
933 ULONGEST clear_bv;
934 static const gdb_byte zero[I386_MAX_REGISTER_SIZE] = { 0 };
935 enum
936 {
937 none = 0x0,
938 x87 = 0x1,
939 sse = 0x2,
940 avxh = 0x4,
941 mpx = 0x8,
942 avx512_k = 0x10,
943 avx512_zmm_h = 0x20,
944 avx512_ymmh_avx512 = 0x40,
945 avx512_xmm_avx512 = 0x80,
946 pkeys = 0x100,
947 all = x87 | sse | avxh | mpx | avx512_k | avx512_zmm_h
948 | avx512_ymmh_avx512 | avx512_xmm_avx512 | pkeys
949 } regclass;
950
951 gdb_assert (regs != NULL);
952 gdb_assert (tdep->st0_regnum >= I386_ST0_REGNUM);
953 gdb_assert (tdep->num_xmm_regs > 0);
954
955 if (regnum == -1)
956 regclass = all;
957 else if (regnum >= I387_PKRU_REGNUM (tdep)
958 && regnum < I387_PKEYSEND_REGNUM (tdep))
959 regclass = pkeys;
960 else if (regnum >= I387_ZMM0H_REGNUM (tdep)
961 && regnum < I387_ZMMENDH_REGNUM (tdep))
962 regclass = avx512_zmm_h;
963 else if (regnum >= I387_K0_REGNUM (tdep)
964 && regnum < I387_KEND_REGNUM (tdep))
965 regclass = avx512_k;
966 else if (regnum >= I387_YMM16H_REGNUM (tdep)
967 && regnum < I387_YMMH_AVX512_END_REGNUM (tdep))
968 regclass = avx512_ymmh_avx512;
969 else if (regnum >= I387_XMM16_REGNUM (tdep)
970 && regnum < I387_XMM_AVX512_END_REGNUM (tdep))
971 regclass = avx512_xmm_avx512;
972 else if (regnum >= I387_YMM0H_REGNUM (tdep)
973 && regnum < I387_YMMENDH_REGNUM (tdep))
974 regclass = avxh;
975 else if (regnum >= I387_BND0R_REGNUM (tdep)
976 && regnum < I387_MPXEND_REGNUM (tdep))
977 regclass = mpx;
978 else if (regnum >= I387_XMM0_REGNUM (tdep)
979 && regnum < I387_MXCSR_REGNUM (tdep))
980 regclass = sse;
981 else if (regnum >= I387_ST0_REGNUM (tdep)
982 && regnum < I387_FCTRL_REGNUM (tdep))
983 regclass = x87;
984 else
985 regclass = none;
986
987 clear_bv = i387_xsave_get_clear_bv (gdbarch, xsave);
988
989 /* With the delayed xsave mechanism, in between the program
990 starting, and the program accessing the vector registers for the
991 first time, the register's values are invalid. The kernel
992 initializes register states to zero when they are set the first
993 time in a program. This means that from the user-space programs'
994 perspective, it's the same as if the registers have always been
995 zero from the start of the program. Therefore, the debugger
996 should provide the same illusion to the user. */
997
998 switch (regclass)
999 {
1000 case none:
1001 break;
1002
1003 case pkeys:
1004 if ((clear_bv & X86_XSTATE_PKRU))
1005 regcache->raw_supply (regnum, zero);
1006 else
1007 regcache->raw_supply (regnum, XSAVE_PKEYS_ADDR (tdep, regs, regnum));
1008 return;
1009
1010 case avx512_zmm_h:
1011 if ((clear_bv & (regnum < zmm_endlo_regnum ? X86_XSTATE_ZMM_H
1012 : X86_XSTATE_ZMM)))
1013 regcache->raw_supply (regnum, zero);
1014 else
1015 regcache->raw_supply (regnum,
1016 XSAVE_AVX512_ZMM_H_ADDR (tdep, regs, regnum));
1017 return;
1018
1019 case avx512_k:
1020 if ((clear_bv & X86_XSTATE_K))
1021 regcache->raw_supply (regnum, zero);
1022 else
1023 regcache->raw_supply (regnum, XSAVE_AVX512_K_ADDR (tdep, regs, regnum));
1024 return;
1025
1026 case avx512_ymmh_avx512:
1027 if ((clear_bv & X86_XSTATE_ZMM))
1028 regcache->raw_supply (regnum, zero);
1029 else
1030 regcache->raw_supply (regnum,
1031 XSAVE_YMM_AVX512_ADDR (tdep, regs, regnum));
1032 return;
1033
1034 case avx512_xmm_avx512:
1035 if ((clear_bv & X86_XSTATE_ZMM))
1036 regcache->raw_supply (regnum, zero);
1037 else
1038 regcache->raw_supply (regnum,
1039 XSAVE_XMM_AVX512_ADDR (tdep, regs, regnum));
1040 return;
1041
1042 case avxh:
1043 if ((clear_bv & X86_XSTATE_AVX))
1044 regcache->raw_supply (regnum, zero);
1045 else
1046 regcache->raw_supply (regnum, XSAVE_AVXH_ADDR (tdep, regs, regnum));
1047 return;
1048
1049 case mpx:
1050 if ((clear_bv & X86_XSTATE_BNDREGS))
1051 regcache->raw_supply (regnum, zero);
1052 else
1053 regcache->raw_supply (regnum, XSAVE_MPX_ADDR (tdep, regs, regnum));
1054 return;
1055
1056 case sse:
1057 if ((clear_bv & X86_XSTATE_SSE))
1058 regcache->raw_supply (regnum, zero);
1059 else
1060 regcache->raw_supply (regnum, FXSAVE_ADDR (tdep, regs, regnum));
1061 return;
1062
1063 case x87:
1064 if ((clear_bv & X86_XSTATE_X87))
1065 regcache->raw_supply (regnum, zero);
1066 else
1067 regcache->raw_supply (regnum, FXSAVE_ADDR (tdep, regs, regnum));
1068 return;
1069
1070 case all:
1071 /* Handle PKEYS registers. */
1072 if ((tdep->xcr0 & X86_XSTATE_PKRU))
1073 {
1074 if ((clear_bv & X86_XSTATE_PKRU))
1075 {
1076 for (i = I387_PKRU_REGNUM (tdep);
1077 i < I387_PKEYSEND_REGNUM (tdep);
1078 i++)
1079 regcache->raw_supply (i, zero);
1080 }
1081 else
1082 {
1083 for (i = I387_PKRU_REGNUM (tdep);
1084 i < I387_PKEYSEND_REGNUM (tdep);
1085 i++)
1086 regcache->raw_supply (i, XSAVE_PKEYS_ADDR (tdep, regs, i));
1087 }
1088 }
1089
1090 /* Handle the upper halves of the low 8/16 ZMM registers. */
1091 if ((tdep->xcr0 & X86_XSTATE_ZMM_H))
1092 {
1093 if ((clear_bv & X86_XSTATE_ZMM_H))
1094 {
1095 for (i = I387_ZMM0H_REGNUM (tdep); i < zmm_endlo_regnum; i++)
1096 regcache->raw_supply (i, zero);
1097 }
1098 else
1099 {
1100 for (i = I387_ZMM0H_REGNUM (tdep); i < zmm_endlo_regnum; i++)
1101 regcache->raw_supply (i,
1102 XSAVE_AVX512_ZMM_H_ADDR (tdep, regs, i));
1103 }
1104 }
1105
1106 /* Handle AVX512 OpMask registers. */
1107 if ((tdep->xcr0 & X86_XSTATE_K))
1108 {
1109 if ((clear_bv & X86_XSTATE_K))
1110 {
1111 for (i = I387_K0_REGNUM (tdep);
1112 i < I387_KEND_REGNUM (tdep);
1113 i++)
1114 regcache->raw_supply (i, zero);
1115 }
1116 else
1117 {
1118 for (i = I387_K0_REGNUM (tdep);
1119 i < I387_KEND_REGNUM (tdep);
1120 i++)
1121 regcache->raw_supply (i, XSAVE_AVX512_K_ADDR (tdep, regs, i));
1122 }
1123 }
1124
1125 /* Handle the upper 16 ZMM/YMM/XMM registers (if any). */
1126 if ((tdep->xcr0 & X86_XSTATE_ZMM))
1127 {
1128 if ((clear_bv & X86_XSTATE_ZMM))
1129 {
1130 for (i = zmm_endlo_regnum; i < I387_ZMMENDH_REGNUM (tdep); i++)
1131 regcache->raw_supply (i, zero);
1132 for (i = I387_YMM16H_REGNUM (tdep);
1133 i < I387_YMMH_AVX512_END_REGNUM (tdep);
1134 i++)
1135 regcache->raw_supply (i, zero);
1136 for (i = I387_XMM16_REGNUM (tdep);
1137 i < I387_XMM_AVX512_END_REGNUM (tdep);
1138 i++)
1139 regcache->raw_supply (i, zero);
1140 }
1141 else
1142 {
1143 for (i = zmm_endlo_regnum; i < I387_ZMMENDH_REGNUM (tdep); i++)
1144 regcache->raw_supply (i,
1145 XSAVE_AVX512_ZMM_H_ADDR (tdep, regs, i));
1146 for (i = I387_YMM16H_REGNUM (tdep);
1147 i < I387_YMMH_AVX512_END_REGNUM (tdep);
1148 i++)
1149 regcache->raw_supply (i, XSAVE_YMM_AVX512_ADDR (tdep, regs, i));
1150 for (i = I387_XMM16_REGNUM (tdep);
1151 i < I387_XMM_AVX512_END_REGNUM (tdep);
1152 i++)
1153 regcache->raw_supply (i, XSAVE_XMM_AVX512_ADDR (tdep, regs, i));
1154 }
1155 }
1156 /* Handle the upper YMM registers. */
1157 if ((tdep->xcr0 & X86_XSTATE_AVX))
1158 {
1159 if ((clear_bv & X86_XSTATE_AVX))
1160 {
1161 for (i = I387_YMM0H_REGNUM (tdep);
1162 i < I387_YMMENDH_REGNUM (tdep);
1163 i++)
1164 regcache->raw_supply (i, zero);
1165 }
1166 else
1167 {
1168 for (i = I387_YMM0H_REGNUM (tdep);
1169 i < I387_YMMENDH_REGNUM (tdep);
1170 i++)
1171 regcache->raw_supply (i, XSAVE_AVXH_ADDR (tdep, regs, i));
1172 }
1173 }
1174
1175 /* Handle the MPX registers. */
1176 if ((tdep->xcr0 & X86_XSTATE_BNDREGS))
1177 {
1178 if (clear_bv & X86_XSTATE_BNDREGS)
1179 {
1180 for (i = I387_BND0R_REGNUM (tdep);
1181 i < I387_BNDCFGU_REGNUM (tdep); i++)
1182 regcache->raw_supply (i, zero);
1183 }
1184 else
1185 {
1186 for (i = I387_BND0R_REGNUM (tdep);
1187 i < I387_BNDCFGU_REGNUM (tdep); i++)
1188 regcache->raw_supply (i, XSAVE_MPX_ADDR (tdep, regs, i));
1189 }
1190 }
1191
1192 /* Handle the MPX registers. */
1193 if ((tdep->xcr0 & X86_XSTATE_BNDCFG))
1194 {
1195 if (clear_bv & X86_XSTATE_BNDCFG)
1196 {
1197 for (i = I387_BNDCFGU_REGNUM (tdep);
1198 i < I387_MPXEND_REGNUM (tdep); i++)
1199 regcache->raw_supply (i, zero);
1200 }
1201 else
1202 {
1203 for (i = I387_BNDCFGU_REGNUM (tdep);
1204 i < I387_MPXEND_REGNUM (tdep); i++)
1205 regcache->raw_supply (i, XSAVE_MPX_ADDR (tdep, regs, i));
1206 }
1207 }
1208
1209 /* Handle the XMM registers. */
1210 if ((tdep->xcr0 & X86_XSTATE_SSE))
1211 {
1212 if ((clear_bv & X86_XSTATE_SSE))
1213 {
1214 for (i = I387_XMM0_REGNUM (tdep);
1215 i < I387_MXCSR_REGNUM (tdep);
1216 i++)
1217 regcache->raw_supply (i, zero);
1218 }
1219 else
1220 {
1221 for (i = I387_XMM0_REGNUM (tdep);
1222 i < I387_MXCSR_REGNUM (tdep); i++)
1223 regcache->raw_supply (i, FXSAVE_ADDR (tdep, regs, i));
1224 }
1225 }
1226
1227 /* Handle the x87 registers. */
1228 if ((tdep->xcr0 & X86_XSTATE_X87))
1229 {
1230 if ((clear_bv & X86_XSTATE_X87))
1231 {
1232 for (i = I387_ST0_REGNUM (tdep);
1233 i < I387_FCTRL_REGNUM (tdep);
1234 i++)
1235 regcache->raw_supply (i, zero);
1236 }
1237 else
1238 {
1239 for (i = I387_ST0_REGNUM (tdep);
1240 i < I387_FCTRL_REGNUM (tdep);
1241 i++)
1242 regcache->raw_supply (i, FXSAVE_ADDR (tdep, regs, i));
1243 }
1244 }
1245 break;
1246 }
1247
1248 /* Only handle x87 control registers. */
1249 for (i = I387_FCTRL_REGNUM (tdep); i < I387_XMM0_REGNUM (tdep); i++)
1250 if (regnum == -1 || regnum == i)
1251 {
1252 if (clear_bv & X86_XSTATE_X87)
1253 {
1254 if (i == I387_FCTRL_REGNUM (tdep))
1255 {
1256 gdb_byte buf[4];
1257
1258 store_unsigned_integer (buf, 4, byte_order,
1259 I387_FCTRL_INIT_VAL);
1260 regcache->raw_supply (i, buf);
1261 }
1262 else if (i == I387_FTAG_REGNUM (tdep))
1263 {
1264 gdb_byte buf[4];
1265
1266 store_unsigned_integer (buf, 4, byte_order, 0xffff);
1267 regcache->raw_supply (i, buf);
1268 }
1269 else
1270 regcache->raw_supply (i, zero);
1271 }
1272 /* Most of the FPU control registers occupy only 16 bits in
1273 the xsave extended state. Give those a special treatment. */
1274 else if (i != I387_FIOFF_REGNUM (tdep)
1275 && i != I387_FOOFF_REGNUM (tdep))
1276 {
1277 gdb_byte val[4];
1278
1279 memcpy (val, FXSAVE_ADDR (tdep, regs, i), 2);
1280 val[2] = val[3] = 0;
1281 if (i == I387_FOP_REGNUM (tdep))
1282 val[1] &= ((1 << 3) - 1);
1283 else if (i == I387_FTAG_REGNUM (tdep))
1284 {
1285 /* The fxsave area contains a simplified version of
1286 the tag word. We have to look at the actual 80-bit
1287 FP data to recreate the traditional i387 tag word. */
1288
1289 unsigned long ftag = 0;
1290 int fpreg;
1291 int top;
1292
1293 top = ((FXSAVE_ADDR (tdep, regs,
1294 I387_FSTAT_REGNUM (tdep)))[1] >> 3);
1295 top &= 0x7;
1296
1297 for (fpreg = 7; fpreg >= 0; fpreg--)
1298 {
1299 int tag;
1300
1301 if (val[0] & (1 << fpreg))
1302 {
1303 int thisreg = (fpreg + 8 - top) % 8
1304 + I387_ST0_REGNUM (tdep);
1305 tag = i387_tag (FXSAVE_ADDR (tdep, regs, thisreg));
1306 }
1307 else
1308 tag = 3; /* Empty */
1309
1310 ftag |= tag << (2 * fpreg);
1311 }
1312 val[0] = ftag & 0xff;
1313 val[1] = (ftag >> 8) & 0xff;
1314 }
1315 regcache->raw_supply (i, val);
1316 }
1317 else
1318 regcache->raw_supply (i, FXSAVE_ADDR (tdep, regs, i));
1319 }
1320
1321 if (regnum == I387_MXCSR_REGNUM (tdep) || regnum == -1)
1322 {
1323 /* The MXCSR register is placed into the xsave buffer if either the
1324 AVX or SSE features are enabled. */
1325 if ((clear_bv & (X86_XSTATE_AVX | X86_XSTATE_SSE))
1326 == (X86_XSTATE_AVX | X86_XSTATE_SSE))
1327 {
1328 gdb_byte buf[4];
1329
1330 store_unsigned_integer (buf, 4, byte_order, I387_MXCSR_INIT_VAL);
1331 regcache->raw_supply (I387_MXCSR_REGNUM (tdep), buf);
1332 }
1333 else
1334 regcache->raw_supply (I387_MXCSR_REGNUM (tdep),
1335 FXSAVE_MXCSR_ADDR (regs));
1336 }
1337 }
1338
1339 /* Similar to i387_collect_fxsave, but use XSAVE extended state. */
1340
1341 void
1342 i387_collect_xsave (const struct regcache *regcache, int regnum,
1343 void *xsave, int gcore)
1344 {
1345 struct gdbarch *gdbarch = regcache->arch ();
1346 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1347 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1348 gdb_byte *p, *regs = (gdb_byte *) xsave;
1349 gdb_byte raw[I386_MAX_REGISTER_SIZE];
1350 ULONGEST initial_xstate_bv, clear_bv, xstate_bv = 0;
1351 unsigned int i;
1352 /* See the comment in i387_supply_xsave(). */
1353 unsigned int zmm_endlo_regnum = I387_ZMM0H_REGNUM (tdep)
1354 + std::min (tdep->num_zmm_regs, 16);
1355 enum
1356 {
1357 x87_ctrl_or_mxcsr = 0x1,
1358 x87 = 0x2,
1359 sse = 0x4,
1360 avxh = 0x8,
1361 mpx = 0x10,
1362 avx512_k = 0x20,
1363 avx512_zmm_h = 0x40,
1364 avx512_ymmh_avx512 = 0x80,
1365 avx512_xmm_avx512 = 0x100,
1366 pkeys = 0x200,
1367 all = x87 | sse | avxh | mpx | avx512_k | avx512_zmm_h
1368 | avx512_ymmh_avx512 | avx512_xmm_avx512 | pkeys
1369 } regclass;
1370
1371 gdb_assert (tdep->st0_regnum >= I386_ST0_REGNUM);
1372 gdb_assert (tdep->num_xmm_regs > 0);
1373
1374 if (regnum == -1)
1375 regclass = all;
1376 else if (regnum >= I387_PKRU_REGNUM (tdep)
1377 && regnum < I387_PKEYSEND_REGNUM (tdep))
1378 regclass = pkeys;
1379 else if (regnum >= I387_ZMM0H_REGNUM (tdep)
1380 && regnum < I387_ZMMENDH_REGNUM (tdep))
1381 regclass = avx512_zmm_h;
1382 else if (regnum >= I387_K0_REGNUM (tdep)
1383 && regnum < I387_KEND_REGNUM (tdep))
1384 regclass = avx512_k;
1385 else if (regnum >= I387_YMM16H_REGNUM (tdep)
1386 && regnum < I387_YMMH_AVX512_END_REGNUM (tdep))
1387 regclass = avx512_ymmh_avx512;
1388 else if (regnum >= I387_XMM16_REGNUM (tdep)
1389 && regnum < I387_XMM_AVX512_END_REGNUM (tdep))
1390 regclass = avx512_xmm_avx512;
1391 else if (regnum >= I387_YMM0H_REGNUM (tdep)
1392 && regnum < I387_YMMENDH_REGNUM (tdep))
1393 regclass = avxh;
1394 else if (regnum >= I387_BND0R_REGNUM (tdep)
1395 && regnum < I387_MPXEND_REGNUM (tdep))
1396 regclass = mpx;
1397 else if (regnum >= I387_XMM0_REGNUM (tdep)
1398 && regnum < I387_MXCSR_REGNUM (tdep))
1399 regclass = sse;
1400 else if (regnum >= I387_ST0_REGNUM (tdep)
1401 && regnum < I387_FCTRL_REGNUM (tdep))
1402 regclass = x87;
1403 else if ((regnum >= I387_FCTRL_REGNUM (tdep)
1404 && regnum < I387_XMM0_REGNUM (tdep))
1405 || regnum == I387_MXCSR_REGNUM (tdep))
1406 regclass = x87_ctrl_or_mxcsr;
1407 else
1408 internal_error (__FILE__, __LINE__, _("invalid i387 regnum %d"), regnum);
1409
1410 if (gcore)
1411 {
1412 /* Clear XSAVE extended state. */
1413 memset (regs, 0, X86_XSTATE_SIZE (tdep->xcr0));
1414
1415 /* Update XCR0 and `xstate_bv' with XCR0 for gcore. */
1416 if (tdep->xsave_xcr0_offset != -1)
1417 memcpy (regs + tdep->xsave_xcr0_offset, &tdep->xcr0, 8);
1418 memcpy (XSAVE_XSTATE_BV_ADDR (regs), &tdep->xcr0, 8);
1419 }
1420
1421 /* The supported bits in `xstat_bv' are 8 bytes. */
1422 initial_xstate_bv = extract_unsigned_integer (XSAVE_XSTATE_BV_ADDR (regs),
1423 8, byte_order);
1424 clear_bv = (~(initial_xstate_bv)) & tdep->xcr0;
1425
1426 /* The XSAVE buffer was filled lazily by the kernel. Only those
1427 features that are enabled were written into the buffer, disabled
1428 features left the buffer uninitialised. In order to identify if any
1429 registers have changed we will be comparing the register cache
1430 version to the version in the XSAVE buffer, it is important then that
1431 at this point we initialise to the default values any features in
1432 XSAVE that are not yet initialised.
1433
1434 This could be made more efficient, we know which features (from
1435 REGNUM) we will be potentially updating, and could limit ourselves to
1436 only clearing that feature. However, the extra complexity does not
1437 seem justified at this point. */
1438 if (clear_bv)
1439 {
1440 if ((clear_bv & X86_XSTATE_PKRU))
1441 for (i = I387_PKRU_REGNUM (tdep);
1442 i < I387_PKEYSEND_REGNUM (tdep); i++)
1443 memset (XSAVE_PKEYS_ADDR (tdep, regs, i), 0, 4);
1444
1445 if ((clear_bv & X86_XSTATE_BNDREGS))
1446 for (i = I387_BND0R_REGNUM (tdep);
1447 i < I387_BNDCFGU_REGNUM (tdep); i++)
1448 memset (XSAVE_MPX_ADDR (tdep, regs, i), 0, 16);
1449
1450 if ((clear_bv & X86_XSTATE_BNDCFG))
1451 for (i = I387_BNDCFGU_REGNUM (tdep);
1452 i < I387_MPXEND_REGNUM (tdep); i++)
1453 memset (XSAVE_MPX_ADDR (tdep, regs, i), 0, 8);
1454
1455 if ((clear_bv & X86_XSTATE_ZMM_H))
1456 for (i = I387_ZMM0H_REGNUM (tdep); i < zmm_endlo_regnum; i++)
1457 memset (XSAVE_AVX512_ZMM_H_ADDR (tdep, regs, i), 0, 32);
1458
1459 if ((clear_bv & X86_XSTATE_K))
1460 for (i = I387_K0_REGNUM (tdep);
1461 i < I387_KEND_REGNUM (tdep); i++)
1462 memset (XSAVE_AVX512_K_ADDR (tdep, regs, i), 0, 8);
1463
1464 if ((clear_bv & X86_XSTATE_ZMM))
1465 {
1466 for (i = zmm_endlo_regnum; i < I387_ZMMENDH_REGNUM (tdep); i++)
1467 memset (XSAVE_AVX512_ZMM_H_ADDR (tdep, regs, i), 0, 32);
1468 for (i = I387_YMM16H_REGNUM (tdep);
1469 i < I387_YMMH_AVX512_END_REGNUM (tdep); i++)
1470 memset (XSAVE_YMM_AVX512_ADDR (tdep, regs, i), 0, 16);
1471 for (i = I387_XMM16_REGNUM (tdep);
1472 i < I387_XMM_AVX512_END_REGNUM (tdep); i++)
1473 memset (XSAVE_XMM_AVX512_ADDR (tdep, regs, i), 0, 16);
1474 }
1475
1476 if ((clear_bv & X86_XSTATE_AVX))
1477 for (i = I387_YMM0H_REGNUM (tdep);
1478 i < I387_YMMENDH_REGNUM (tdep); i++)
1479 memset (XSAVE_AVXH_ADDR (tdep, regs, i), 0, 16);
1480
1481 if ((clear_bv & X86_XSTATE_SSE))
1482 for (i = I387_XMM0_REGNUM (tdep);
1483 i < I387_MXCSR_REGNUM (tdep); i++)
1484 memset (FXSAVE_ADDR (tdep, regs, i), 0, 16);
1485
1486 /* The mxcsr register is written into the xsave buffer if either AVX
1487 or SSE is enabled, so only clear it if both of those features
1488 require clearing. */
1489 if ((clear_bv & (X86_XSTATE_AVX | X86_XSTATE_SSE))
1490 == (X86_XSTATE_AVX | X86_XSTATE_SSE))
1491 store_unsigned_integer (FXSAVE_MXCSR_ADDR (regs), 2, byte_order,
1492 I387_MXCSR_INIT_VAL);
1493
1494 if ((clear_bv & X86_XSTATE_X87))
1495 {
1496 for (i = I387_ST0_REGNUM (tdep);
1497 i < I387_FCTRL_REGNUM (tdep); i++)
1498 memset (FXSAVE_ADDR (tdep, regs, i), 0, 10);
1499
1500 for (i = I387_FCTRL_REGNUM (tdep);
1501 i < I387_XMM0_REGNUM (tdep); i++)
1502 {
1503 if (i == I387_FCTRL_REGNUM (tdep))
1504 store_unsigned_integer (FXSAVE_ADDR (tdep, regs, i), 2,
1505 byte_order, I387_FCTRL_INIT_VAL);
1506 else
1507 memset (FXSAVE_ADDR (tdep, regs, i), 0,
1508 regcache_register_size (regcache, i));
1509 }
1510 }
1511 }
1512
1513 if (regclass == all)
1514 {
1515 /* Check if any PKEYS registers are changed. */
1516 if ((tdep->xcr0 & X86_XSTATE_PKRU))
1517 for (i = I387_PKRU_REGNUM (tdep);
1518 i < I387_PKEYSEND_REGNUM (tdep); i++)
1519 {
1520 regcache->raw_collect (i, raw);
1521 p = XSAVE_PKEYS_ADDR (tdep, regs, i);
1522 if (memcmp (raw, p, 4) != 0)
1523 {
1524 xstate_bv |= X86_XSTATE_PKRU;
1525 memcpy (p, raw, 4);
1526 }
1527 }
1528
1529 /* Check if any ZMMH registers are changed. */
1530 if ((tdep->xcr0 & (X86_XSTATE_ZMM_H | X86_XSTATE_ZMM)))
1531 for (i = I387_ZMM0H_REGNUM (tdep);
1532 i < I387_ZMMENDH_REGNUM (tdep); i++)
1533 {
1534 regcache->raw_collect (i, raw);
1535 p = XSAVE_AVX512_ZMM_H_ADDR (tdep, regs, i);
1536 if (memcmp (raw, p, 32) != 0)
1537 {
1538 xstate_bv |= (X86_XSTATE_ZMM_H | X86_XSTATE_ZMM);
1539 memcpy (p, raw, 32);
1540 }
1541 }
1542
1543 /* Check if any K registers are changed. */
1544 if ((tdep->xcr0 & X86_XSTATE_K))
1545 for (i = I387_K0_REGNUM (tdep);
1546 i < I387_KEND_REGNUM (tdep); i++)
1547 {
1548 regcache->raw_collect (i, raw);
1549 p = XSAVE_AVX512_K_ADDR (tdep, regs, i);
1550 if (memcmp (raw, p, 8) != 0)
1551 {
1552 xstate_bv |= X86_XSTATE_K;
1553 memcpy (p, raw, 8);
1554 }
1555 }
1556
1557 /* Check if any XMM or upper YMM registers are changed. */
1558 if ((tdep->xcr0 & X86_XSTATE_ZMM))
1559 {
1560 for (i = I387_YMM16H_REGNUM (tdep);
1561 i < I387_YMMH_AVX512_END_REGNUM (tdep); i++)
1562 {
1563 regcache->raw_collect (i, raw);
1564 p = XSAVE_YMM_AVX512_ADDR (tdep, regs, i);
1565 if (memcmp (raw, p, 16) != 0)
1566 {
1567 xstate_bv |= X86_XSTATE_ZMM;
1568 memcpy (p, raw, 16);
1569 }
1570 }
1571 for (i = I387_XMM16_REGNUM (tdep);
1572 i < I387_XMM_AVX512_END_REGNUM (tdep); i++)
1573 {
1574 regcache->raw_collect (i, raw);
1575 p = XSAVE_XMM_AVX512_ADDR (tdep, regs, i);
1576 if (memcmp (raw, p, 16) != 0)
1577 {
1578 xstate_bv |= X86_XSTATE_ZMM;
1579 memcpy (p, raw, 16);
1580 }
1581 }
1582 }
1583
1584 /* Check if any upper MPX registers are changed. */
1585 if ((tdep->xcr0 & X86_XSTATE_BNDREGS))
1586 for (i = I387_BND0R_REGNUM (tdep);
1587 i < I387_BNDCFGU_REGNUM (tdep); i++)
1588 {
1589 regcache->raw_collect (i, raw);
1590 p = XSAVE_MPX_ADDR (tdep, regs, i);
1591 if (memcmp (raw, p, 16))
1592 {
1593 xstate_bv |= X86_XSTATE_BNDREGS;
1594 memcpy (p, raw, 16);
1595 }
1596 }
1597
1598 /* Check if any upper MPX registers are changed. */
1599 if ((tdep->xcr0 & X86_XSTATE_BNDCFG))
1600 for (i = I387_BNDCFGU_REGNUM (tdep);
1601 i < I387_MPXEND_REGNUM (tdep); i++)
1602 {
1603 regcache->raw_collect (i, raw);
1604 p = XSAVE_MPX_ADDR (tdep, regs, i);
1605 if (memcmp (raw, p, 8))
1606 {
1607 xstate_bv |= X86_XSTATE_BNDCFG;
1608 memcpy (p, raw, 8);
1609 }
1610 }
1611
1612 /* Check if any upper YMM registers are changed. */
1613 if ((tdep->xcr0 & X86_XSTATE_AVX))
1614 for (i = I387_YMM0H_REGNUM (tdep);
1615 i < I387_YMMENDH_REGNUM (tdep); i++)
1616 {
1617 regcache->raw_collect (i, raw);
1618 p = XSAVE_AVXH_ADDR (tdep, regs, i);
1619 if (memcmp (raw, p, 16))
1620 {
1621 xstate_bv |= X86_XSTATE_AVX;
1622 memcpy (p, raw, 16);
1623 }
1624 }
1625
1626 /* Check if any SSE registers are changed. */
1627 if ((tdep->xcr0 & X86_XSTATE_SSE))
1628 for (i = I387_XMM0_REGNUM (tdep);
1629 i < I387_MXCSR_REGNUM (tdep); i++)
1630 {
1631 regcache->raw_collect (i, raw);
1632 p = FXSAVE_ADDR (tdep, regs, i);
1633 if (memcmp (raw, p, 16))
1634 {
1635 xstate_bv |= X86_XSTATE_SSE;
1636 memcpy (p, raw, 16);
1637 }
1638 }
1639
1640 if ((tdep->xcr0 & X86_XSTATE_AVX) || (tdep->xcr0 & X86_XSTATE_SSE))
1641 {
1642 i = I387_MXCSR_REGNUM (tdep);
1643 regcache->raw_collect (i, raw);
1644 p = FXSAVE_MXCSR_ADDR (regs);
1645 if (memcmp (raw, p, 4))
1646 {
1647 /* Now, we need to mark one of either SSE of AVX as enabled.
1648 We could pick either. What we do is check to see if one
1649 of the features is already enabled, if it is then we leave
1650 it at that, otherwise we pick SSE. */
1651 if ((xstate_bv & (X86_XSTATE_SSE | X86_XSTATE_AVX)) == 0)
1652 xstate_bv |= X86_XSTATE_SSE;
1653 memcpy (p, raw, 4);
1654 }
1655 }
1656
1657 /* Check if any X87 registers are changed. Only the non-control
1658 registers are handled here, the control registers are all handled
1659 later on in this function. */
1660 if ((tdep->xcr0 & X86_XSTATE_X87))
1661 for (i = I387_ST0_REGNUM (tdep);
1662 i < I387_FCTRL_REGNUM (tdep); i++)
1663 {
1664 regcache->raw_collect (i, raw);
1665 p = FXSAVE_ADDR (tdep, regs, i);
1666 if (memcmp (raw, p, 10))
1667 {
1668 xstate_bv |= X86_XSTATE_X87;
1669 memcpy (p, raw, 10);
1670 }
1671 }
1672 }
1673 else
1674 {
1675 /* Check if REGNUM is changed. */
1676 regcache->raw_collect (regnum, raw);
1677
1678 switch (regclass)
1679 {
1680 default:
1681 internal_error (__FILE__, __LINE__,
1682 _("invalid i387 regclass"));
1683
1684 case pkeys:
1685 /* This is a PKEYS register. */
1686 p = XSAVE_PKEYS_ADDR (tdep, regs, regnum);
1687 if (memcmp (raw, p, 4) != 0)
1688 {
1689 xstate_bv |= X86_XSTATE_PKRU;
1690 memcpy (p, raw, 4);
1691 }
1692 break;
1693
1694 case avx512_zmm_h:
1695 /* This is a ZMM register. */
1696 p = XSAVE_AVX512_ZMM_H_ADDR (tdep, regs, regnum);
1697 if (memcmp (raw, p, 32) != 0)
1698 {
1699 xstate_bv |= (X86_XSTATE_ZMM_H | X86_XSTATE_ZMM);
1700 memcpy (p, raw, 32);
1701 }
1702 break;
1703 case avx512_k:
1704 /* This is a AVX512 mask register. */
1705 p = XSAVE_AVX512_K_ADDR (tdep, regs, regnum);
1706 if (memcmp (raw, p, 8) != 0)
1707 {
1708 xstate_bv |= X86_XSTATE_K;
1709 memcpy (p, raw, 8);
1710 }
1711 break;
1712
1713 case avx512_ymmh_avx512:
1714 /* This is an upper YMM16-31 register. */
1715 p = XSAVE_YMM_AVX512_ADDR (tdep, regs, regnum);
1716 if (memcmp (raw, p, 16) != 0)
1717 {
1718 xstate_bv |= X86_XSTATE_ZMM;
1719 memcpy (p, raw, 16);
1720 }
1721 break;
1722
1723 case avx512_xmm_avx512:
1724 /* This is an upper XMM16-31 register. */
1725 p = XSAVE_XMM_AVX512_ADDR (tdep, regs, regnum);
1726 if (memcmp (raw, p, 16) != 0)
1727 {
1728 xstate_bv |= X86_XSTATE_ZMM;
1729 memcpy (p, raw, 16);
1730 }
1731 break;
1732
1733 case avxh:
1734 /* This is an upper YMM register. */
1735 p = XSAVE_AVXH_ADDR (tdep, regs, regnum);
1736 if (memcmp (raw, p, 16))
1737 {
1738 xstate_bv |= X86_XSTATE_AVX;
1739 memcpy (p, raw, 16);
1740 }
1741 break;
1742
1743 case mpx:
1744 if (regnum < I387_BNDCFGU_REGNUM (tdep))
1745 {
1746 regcache->raw_collect (regnum, raw);
1747 p = XSAVE_MPX_ADDR (tdep, regs, regnum);
1748 if (memcmp (raw, p, 16))
1749 {
1750 xstate_bv |= X86_XSTATE_BNDREGS;
1751 memcpy (p, raw, 16);
1752 }
1753 }
1754 else
1755 {
1756 p = XSAVE_MPX_ADDR (tdep, regs, regnum);
1757 xstate_bv |= X86_XSTATE_BNDCFG;
1758 memcpy (p, raw, 8);
1759 }
1760 break;
1761
1762 case sse:
1763 /* This is an SSE register. */
1764 p = FXSAVE_ADDR (tdep, regs, regnum);
1765 if (memcmp (raw, p, 16))
1766 {
1767 xstate_bv |= X86_XSTATE_SSE;
1768 memcpy (p, raw, 16);
1769 }
1770 break;
1771
1772 case x87:
1773 /* This is an x87 register. */
1774 p = FXSAVE_ADDR (tdep, regs, regnum);
1775 if (memcmp (raw, p, 10))
1776 {
1777 xstate_bv |= X86_XSTATE_X87;
1778 memcpy (p, raw, 10);
1779 }
1780 break;
1781
1782 case x87_ctrl_or_mxcsr:
1783 /* We only handle MXCSR here. All other x87 control registers
1784 are handled separately below. */
1785 if (regnum == I387_MXCSR_REGNUM (tdep))
1786 {
1787 p = FXSAVE_MXCSR_ADDR (regs);
1788 if (memcmp (raw, p, 2))
1789 {
1790 /* We're only setting MXCSR, so check the initial state
1791 to see if either of AVX or SSE are already enabled.
1792 If they are then we'll attribute this changed MXCSR to
1793 that feature. If neither feature is enabled, then
1794 we'll attribute this change to the SSE feature. */
1795 xstate_bv |= (initial_xstate_bv
1796 & (X86_XSTATE_AVX | X86_XSTATE_SSE));
1797 if ((xstate_bv & (X86_XSTATE_AVX | X86_XSTATE_SSE)) == 0)
1798 xstate_bv |= X86_XSTATE_SSE;
1799 memcpy (p, raw, 2);
1800 }
1801 }
1802 }
1803 }
1804
1805 /* Only handle x87 control registers. */
1806 for (i = I387_FCTRL_REGNUM (tdep); i < I387_XMM0_REGNUM (tdep); i++)
1807 if (regnum == -1 || regnum == i)
1808 {
1809 /* Most of the FPU control registers occupy only 16 bits in
1810 the xsave extended state. Give those a special treatment. */
1811 if (i != I387_FIOFF_REGNUM (tdep)
1812 && i != I387_FOOFF_REGNUM (tdep))
1813 {
1814 gdb_byte buf[4];
1815
1816 regcache->raw_collect (i, buf);
1817
1818 if (i == I387_FOP_REGNUM (tdep))
1819 {
1820 /* The opcode occupies only 11 bits. Make sure we
1821 don't touch the other bits. */
1822 buf[1] &= ((1 << 3) - 1);
1823 buf[1] |= ((FXSAVE_ADDR (tdep, regs, i))[1] & ~((1 << 3) - 1));
1824 }
1825 else if (i == I387_FTAG_REGNUM (tdep))
1826 {
1827 /* Converting back is much easier. */
1828
1829 unsigned short ftag;
1830 int fpreg;
1831
1832 ftag = (buf[1] << 8) | buf[0];
1833 buf[0] = 0;
1834 buf[1] = 0;
1835
1836 for (fpreg = 7; fpreg >= 0; fpreg--)
1837 {
1838 int tag = (ftag >> (fpreg * 2)) & 3;
1839
1840 if (tag != 3)
1841 buf[0] |= (1 << fpreg);
1842 }
1843 }
1844 p = FXSAVE_ADDR (tdep, regs, i);
1845 if (memcmp (p, buf, 2))
1846 {
1847 xstate_bv |= X86_XSTATE_X87;
1848 memcpy (p, buf, 2);
1849 }
1850 }
1851 else
1852 {
1853 int regsize;
1854
1855 regcache->raw_collect (i, raw);
1856 regsize = regcache_register_size (regcache, i);
1857 p = FXSAVE_ADDR (tdep, regs, i);
1858 if (memcmp (raw, p, regsize))
1859 {
1860 xstate_bv |= X86_XSTATE_X87;
1861 memcpy (p, raw, regsize);
1862 }
1863 }
1864 }
1865
1866 /* Update the corresponding bits in `xstate_bv' if any
1867 registers are changed. */
1868 if (xstate_bv)
1869 {
1870 /* The supported bits in `xstat_bv' are 8 bytes. */
1871 initial_xstate_bv |= xstate_bv;
1872 store_unsigned_integer (XSAVE_XSTATE_BV_ADDR (regs),
1873 8, byte_order,
1874 initial_xstate_bv);
1875 }
1876 }
1877
1878 /* Recreate the FTW (tag word) valid bits from the 80-bit FP data in
1879 *RAW. */
1880
1881 static int
1882 i387_tag (const gdb_byte *raw)
1883 {
1884 int integer;
1885 unsigned int exponent;
1886 unsigned long fraction[2];
1887
1888 integer = raw[7] & 0x80;
1889 exponent = (((raw[9] & 0x7f) << 8) | raw[8]);
1890 fraction[0] = ((raw[3] << 24) | (raw[2] << 16) | (raw[1] << 8) | raw[0]);
1891 fraction[1] = (((raw[7] & 0x7f) << 24) | (raw[6] << 16)
1892 | (raw[5] << 8) | raw[4]);
1893
1894 if (exponent == 0x7fff)
1895 {
1896 /* Special. */
1897 return (2);
1898 }
1899 else if (exponent == 0x0000)
1900 {
1901 if (fraction[0] == 0x0000 && fraction[1] == 0x0000 && !integer)
1902 {
1903 /* Zero. */
1904 return (1);
1905 }
1906 else
1907 {
1908 /* Special. */
1909 return (2);
1910 }
1911 }
1912 else
1913 {
1914 if (integer)
1915 {
1916 /* Valid. */
1917 return (0);
1918 }
1919 else
1920 {
1921 /* Special. */
1922 return (2);
1923 }
1924 }
1925 }
1926
1927 /* Prepare the FPU stack in REGCACHE for a function return. */
1928
1929 void
1930 i387_return_value (struct gdbarch *gdbarch, struct regcache *regcache)
1931 {
1932 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1933 ULONGEST fstat;
1934
1935 /* Set the top of the floating-point register stack to 7. The
1936 actual value doesn't really matter, but 7 is what a normal
1937 function return would end up with if the program started out with
1938 a freshly initialized FPU. */
1939 regcache_raw_read_unsigned (regcache, I387_FSTAT_REGNUM (tdep), &fstat);
1940 fstat |= (7 << 11);
1941 regcache_raw_write_unsigned (regcache, I387_FSTAT_REGNUM (tdep), fstat);
1942
1943 /* Mark %st(1) through %st(7) as empty. Since we set the top of the
1944 floating-point register stack to 7, the appropriate value for the
1945 tag word is 0x3fff. */
1946 regcache_raw_write_unsigned (regcache, I387_FTAG_REGNUM (tdep), 0x3fff);
1947
1948 }
1949
1950 /* See i387-tdep.h. */
1951
1952 void
1953 i387_reset_bnd_regs (struct gdbarch *gdbarch, struct regcache *regcache)
1954 {
1955 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1956
1957 if (I387_BND0R_REGNUM (tdep) > 0)
1958 {
1959 gdb_byte bnd_buf[16];
1960
1961 memset (bnd_buf, 0, 16);
1962 for (int i = 0; i < I387_NUM_BND_REGS; i++)
1963 regcache->raw_write (I387_BND0R_REGNUM (tdep) + i, bnd_buf);
1964 }
1965 }
GDB Binutils - Deliverables
This page took 0.072198 seconds and 4 git commands to generate.