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