projects / deliverable / binutils-gdb.git / blob
? search:


92061098e322ef84a073c0d88065c4ae2dfddba2
[deliverable/binutils-gdb.git] / gdb / i387-tdep.c
1 /* Intel 387 floating point stuff.
2
3 Copyright (C) 1988-2017 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 = (const gdb_byte *) 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 = (gdb_byte *) 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 = (const gdb_byte *) 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 = (gdb_byte *) 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 /* At xsave_pkeys_offset[REGNUM] you find the offset to the location
892 of the PKRU register data structure used by the "xsave"
893 instruction where GDB register REGNUM is stored. */
894
895 static int xsave_pkeys_offset[] =
896 {
897 2688 + 0 * 8 /* %pkru (64 bits in XSTATE, 32-bit actually used by
898 instructions and applications). */
899 };
900
901 #define XSAVE_PKEYS_ADDR(tdep, xsave, regnum) \
902 (xsave + xsave_pkeys_offset[regnum - I387_PKRU_REGNUM (tdep)])
903
904 /* Similar to i387_supply_fxsave, but use XSAVE extended state. */
905
906 void
907 i387_supply_xsave (struct regcache *regcache, int regnum,
908 const void *xsave)
909 {
910 struct gdbarch *gdbarch = get_regcache_arch (regcache);
911 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
912 const gdb_byte *regs = (const gdb_byte *) xsave;
913 int i;
914 ULONGEST clear_bv;
915 static const gdb_byte zero[I386_MAX_REGISTER_SIZE] = { 0 };
916 enum
917 {
918 none = 0x0,
919 x87 = 0x1,
920 sse = 0x2,
921 avxh = 0x4,
922 mpx = 0x8,
923 avx512_k = 0x10,
924 avx512_zmm_h = 0x20,
925 avx512_ymmh_avx512 = 0x40,
926 avx512_xmm_avx512 = 0x80,
927 pkeys = 0x100,
928 all = x87 | sse | avxh | mpx | avx512_k | avx512_zmm_h
929 | avx512_ymmh_avx512 | avx512_xmm_avx512 | pkeys
930 } regclass;
931
932 gdb_assert (regs != NULL);
933 gdb_assert (tdep->st0_regnum >= I386_ST0_REGNUM);
934 gdb_assert (tdep->num_xmm_regs > 0);
935
936 if (regnum == -1)
937 regclass = all;
938 else if (regnum >= I387_PKRU_REGNUM (tdep)
939 && regnum < I387_PKEYSEND_REGNUM (tdep))
940 regclass = pkeys;
941 else if (regnum >= I387_ZMM0H_REGNUM (tdep)
942 && regnum < I387_ZMMENDH_REGNUM (tdep))
943 regclass = avx512_zmm_h;
944 else if (regnum >= I387_K0_REGNUM (tdep)
945 && regnum < I387_KEND_REGNUM (tdep))
946 regclass = avx512_k;
947 else if (regnum >= I387_YMM16H_REGNUM (tdep)
948 && regnum < I387_YMMH_AVX512_END_REGNUM (tdep))
949 regclass = avx512_ymmh_avx512;
950 else if (regnum >= I387_XMM16_REGNUM (tdep)
951 && regnum < I387_XMM_AVX512_END_REGNUM (tdep))
952 regclass = avx512_xmm_avx512;
953 else if (regnum >= I387_YMM0H_REGNUM (tdep)
954 && regnum < I387_YMMENDH_REGNUM (tdep))
955 regclass = avxh;
956 else if (regnum >= I387_BND0R_REGNUM (tdep)
957 && regnum < I387_MPXEND_REGNUM (tdep))
958 regclass = mpx;
959 else if (regnum >= I387_XMM0_REGNUM (tdep)
960 && regnum < I387_MXCSR_REGNUM (tdep))
961 regclass = sse;
962 else if (regnum >= I387_ST0_REGNUM (tdep)
963 && regnum < I387_FCTRL_REGNUM (tdep))
964 regclass = x87;
965 else
966 regclass = none;
967
968 if (regclass != none)
969 {
970 /* Get `xstat_bv'. The supported bits in `xstat_bv' are 8 bytes. */
971 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
972 ULONGEST xstate_bv = 0;
973
974 xstate_bv = extract_unsigned_integer (XSAVE_XSTATE_BV_ADDR (regs),
975 8, byte_order);
976
977 /* Clear part in vector registers if its bit in xstat_bv is zero. */
978 clear_bv = (~(xstate_bv)) & tdep->xcr0;
979 }
980 else
981 clear_bv = X86_XSTATE_ALL_MASK;
982
983 /* With the delayed xsave mechanism, in between the program
984 starting, and the program accessing the vector registers for the
985 first time, the register's values are invalid. The kernel
986 initializes register states to zero when they are set the first
987 time in a program. This means that from the user-space programs'
988 perspective, it's the same as if the registers have always been
989 zero from the start of the program. Therefore, the debugger
990 should provide the same illusion to the user. */
991
992 switch (regclass)
993 {
994 case none:
995 break;
996
997 case pkeys:
998 if ((clear_bv & X86_XSTATE_PKRU))
999 regcache_raw_supply (regcache, regnum, zero);
1000 else
1001 regcache_raw_supply (regcache, regnum,
1002 XSAVE_PKEYS_ADDR (tdep, regs, regnum));
1003 return;
1004
1005 case avx512_zmm_h:
1006 if ((clear_bv & (X86_XSTATE_ZMM_H | X86_XSTATE_ZMM)))
1007 regcache_raw_supply (regcache, regnum, zero);
1008 else
1009 regcache_raw_supply (regcache, regnum,
1010 XSAVE_AVX512_ZMM_H_ADDR (tdep, regs, regnum));
1011 return;
1012
1013 case avx512_k:
1014 if ((clear_bv & X86_XSTATE_K))
1015 regcache_raw_supply (regcache, regnum, zero);
1016 else
1017 regcache_raw_supply (regcache, regnum,
1018 XSAVE_AVX512_K_ADDR (tdep, regs, regnum));
1019 return;
1020
1021 case avx512_ymmh_avx512:
1022 if ((clear_bv & X86_XSTATE_ZMM))
1023 regcache_raw_supply (regcache, regnum, zero);
1024 else
1025 regcache_raw_supply (regcache, regnum,
1026 XSAVE_YMM_AVX512_ADDR (tdep, regs, regnum));
1027 return;
1028
1029 case avx512_xmm_avx512:
1030 if ((clear_bv & X86_XSTATE_ZMM))
1031 regcache_raw_supply (regcache, regnum, zero);
1032 else
1033 regcache_raw_supply (regcache, regnum,
1034 XSAVE_XMM_AVX512_ADDR (tdep, regs, regnum));
1035 return;
1036
1037 case avxh:
1038 if ((clear_bv & X86_XSTATE_AVX))
1039 regcache_raw_supply (regcache, regnum, zero);
1040 else
1041 regcache_raw_supply (regcache, regnum,
1042 XSAVE_AVXH_ADDR (tdep, regs, regnum));
1043 return;
1044
1045 case mpx:
1046 if ((clear_bv & X86_XSTATE_BNDREGS))
1047 regcache_raw_supply (regcache, regnum, zero);
1048 else
1049 regcache_raw_supply (regcache, regnum,
1050 XSAVE_MPX_ADDR (tdep, regs, regnum));
1051 return;
1052
1053 case sse:
1054 if ((clear_bv & X86_XSTATE_SSE))
1055 regcache_raw_supply (regcache, regnum, zero);
1056 else
1057 regcache_raw_supply (regcache, regnum,
1058 FXSAVE_ADDR (tdep, regs, regnum));
1059 return;
1060
1061 case x87:
1062 if ((clear_bv & X86_XSTATE_X87))
1063 regcache_raw_supply (regcache, regnum, zero);
1064 else
1065 regcache_raw_supply (regcache, regnum,
1066 FXSAVE_ADDR (tdep, regs, regnum));
1067 return;
1068
1069 case all:
1070 /* Handle PKEYS registers. */
1071 if ((tdep->xcr0 & X86_XSTATE_PKRU))
1072 {
1073 if ((clear_bv & X86_XSTATE_PKRU))
1074 {
1075 for (i = I387_PKRU_REGNUM (tdep);
1076 i < I387_PKEYSEND_REGNUM (tdep);
1077 i++)
1078 regcache_raw_supply (regcache, i, zero);
1079 }
1080 else
1081 {
1082 for (i = I387_PKRU_REGNUM (tdep);
1083 i < I387_PKEYSEND_REGNUM (tdep);
1084 i++)
1085 regcache_raw_supply (regcache, i,
1086 XSAVE_PKEYS_ADDR (tdep, regs, i));
1087 }
1088 }
1089
1090 /* Handle the upper ZMM registers. */
1091 if ((tdep->xcr0 & (X86_XSTATE_ZMM_H | X86_XSTATE_ZMM)))
1092 {
1093 if ((clear_bv & (X86_XSTATE_ZMM_H | X86_XSTATE_ZMM)))
1094 {
1095 for (i = I387_ZMM0H_REGNUM (tdep);
1096 i < I387_ZMMENDH_REGNUM (tdep);
1097 i++)
1098 regcache_raw_supply (regcache, i, zero);
1099 }
1100 else
1101 {
1102 for (i = I387_ZMM0H_REGNUM (tdep);
1103 i < I387_ZMMENDH_REGNUM (tdep);
1104 i++)
1105 regcache_raw_supply (regcache, i,
1106 XSAVE_AVX512_ZMM_H_ADDR (tdep, regs, i));
1107 }
1108 }
1109
1110 /* Handle AVX512 OpMask registers. */
1111 if ((tdep->xcr0 & X86_XSTATE_K))
1112 {
1113 if ((clear_bv & X86_XSTATE_K))
1114 {
1115 for (i = I387_K0_REGNUM (tdep);
1116 i < I387_KEND_REGNUM (tdep);
1117 i++)
1118 regcache_raw_supply (regcache, i, zero);
1119 }
1120 else
1121 {
1122 for (i = I387_K0_REGNUM (tdep);
1123 i < I387_KEND_REGNUM (tdep);
1124 i++)
1125 regcache_raw_supply (regcache, i,
1126 XSAVE_AVX512_K_ADDR (tdep, regs, i));
1127 }
1128 }
1129
1130 /* Handle the YMM_AVX512 registers. */
1131 if ((tdep->xcr0 & X86_XSTATE_ZMM))
1132 {
1133 if ((clear_bv & X86_XSTATE_ZMM))
1134 {
1135 for (i = I387_YMM16H_REGNUM (tdep);
1136 i < I387_YMMH_AVX512_END_REGNUM (tdep);
1137 i++)
1138 regcache_raw_supply (regcache, i, zero);
1139 for (i = I387_XMM16_REGNUM (tdep);
1140 i < I387_XMM_AVX512_END_REGNUM (tdep);
1141 i++)
1142 regcache_raw_supply (regcache, i, zero);
1143 }
1144 else
1145 {
1146 for (i = I387_YMM16H_REGNUM (tdep);
1147 i < I387_YMMH_AVX512_END_REGNUM (tdep);
1148 i++)
1149 regcache_raw_supply (regcache, i,
1150 XSAVE_YMM_AVX512_ADDR (tdep, regs, i));
1151 for (i = I387_XMM16_REGNUM (tdep);
1152 i < I387_XMM_AVX512_END_REGNUM (tdep);
1153 i++)
1154 regcache_raw_supply (regcache, i,
1155 XSAVE_XMM_AVX512_ADDR (tdep, regs, i));
1156 }
1157 }
1158 /* Handle the upper YMM registers. */
1159 if ((tdep->xcr0 & X86_XSTATE_AVX))
1160 {
1161 if ((clear_bv & X86_XSTATE_AVX))
1162 {
1163 for (i = I387_YMM0H_REGNUM (tdep);
1164 i < I387_YMMENDH_REGNUM (tdep);
1165 i++)
1166 regcache_raw_supply (regcache, i, zero);
1167 }
1168 else
1169 {
1170 for (i = I387_YMM0H_REGNUM (tdep);
1171 i < I387_YMMENDH_REGNUM (tdep);
1172 i++)
1173 regcache_raw_supply (regcache, i,
1174 XSAVE_AVXH_ADDR (tdep, regs, i));
1175 }
1176 }
1177
1178 /* Handle the MPX registers. */
1179 if ((tdep->xcr0 & X86_XSTATE_BNDREGS))
1180 {
1181 if (clear_bv & X86_XSTATE_BNDREGS)
1182 {
1183 for (i = I387_BND0R_REGNUM (tdep);
1184 i < I387_BNDCFGU_REGNUM (tdep); i++)
1185 regcache_raw_supply (regcache, i, zero);
1186 }
1187 else
1188 {
1189 for (i = I387_BND0R_REGNUM (tdep);
1190 i < I387_BNDCFGU_REGNUM (tdep); i++)
1191 regcache_raw_supply (regcache, i,
1192 XSAVE_MPX_ADDR (tdep, regs, i));
1193 }
1194 }
1195
1196 /* Handle the MPX registers. */
1197 if ((tdep->xcr0 & X86_XSTATE_BNDCFG))
1198 {
1199 if (clear_bv & X86_XSTATE_BNDCFG)
1200 {
1201 for (i = I387_BNDCFGU_REGNUM (tdep);
1202 i < I387_MPXEND_REGNUM (tdep); i++)
1203 regcache_raw_supply (regcache, i, zero);
1204 }
1205 else
1206 {
1207 for (i = I387_BNDCFGU_REGNUM (tdep);
1208 i < I387_MPXEND_REGNUM (tdep); i++)
1209 regcache_raw_supply (regcache, i,
1210 XSAVE_MPX_ADDR (tdep, regs, i));
1211 }
1212 }
1213
1214 /* Handle the XMM registers. */
1215 if ((tdep->xcr0 & X86_XSTATE_SSE))
1216 {
1217 if ((clear_bv & X86_XSTATE_SSE))
1218 {
1219 for (i = I387_XMM0_REGNUM (tdep);
1220 i < I387_MXCSR_REGNUM (tdep);
1221 i++)
1222 regcache_raw_supply (regcache, i, zero);
1223 }
1224 else
1225 {
1226 for (i = I387_XMM0_REGNUM (tdep);
1227 i < I387_MXCSR_REGNUM (tdep); i++)
1228 regcache_raw_supply (regcache, i,
1229 FXSAVE_ADDR (tdep, regs, i));
1230 }
1231 }
1232
1233 /* Handle the x87 registers. */
1234 if ((tdep->xcr0 & X86_XSTATE_X87))
1235 {
1236 if ((clear_bv & X86_XSTATE_X87))
1237 {
1238 for (i = I387_ST0_REGNUM (tdep);
1239 i < I387_FCTRL_REGNUM (tdep);
1240 i++)
1241 regcache_raw_supply (regcache, i, zero);
1242 }
1243 else
1244 {
1245 for (i = I387_ST0_REGNUM (tdep);
1246 i < I387_FCTRL_REGNUM (tdep);
1247 i++)
1248 regcache_raw_supply (regcache, i, FXSAVE_ADDR (tdep, regs, i));
1249 }
1250 }
1251 break;
1252 }
1253
1254 /* Only handle x87 control registers. */
1255 for (i = I387_FCTRL_REGNUM (tdep); i < I387_XMM0_REGNUM (tdep); i++)
1256 if (regnum == -1 || regnum == i)
1257 {
1258 /* Most of the FPU control registers occupy only 16 bits in
1259 the xsave extended state. Give those a special treatment. */
1260 if (i != I387_FIOFF_REGNUM (tdep)
1261 && i != I387_FOOFF_REGNUM (tdep))
1262 {
1263 gdb_byte val[4];
1264
1265 memcpy (val, FXSAVE_ADDR (tdep, regs, i), 2);
1266 val[2] = val[3] = 0;
1267 if (i == I387_FOP_REGNUM (tdep))
1268 val[1] &= ((1 << 3) - 1);
1269 else if (i== I387_FTAG_REGNUM (tdep))
1270 {
1271 /* The fxsave area contains a simplified version of
1272 the tag word. We have to look at the actual 80-bit
1273 FP data to recreate the traditional i387 tag word. */
1274
1275 unsigned long ftag = 0;
1276 int fpreg;
1277 int top;
1278
1279 top = ((FXSAVE_ADDR (tdep, regs,
1280 I387_FSTAT_REGNUM (tdep)))[1] >> 3);
1281 top &= 0x7;
1282
1283 for (fpreg = 7; fpreg >= 0; fpreg--)
1284 {
1285 int tag;
1286
1287 if (val[0] & (1 << fpreg))
1288 {
1289 int thisreg = (fpreg + 8 - top) % 8
1290 + I387_ST0_REGNUM (tdep);
1291 tag = i387_tag (FXSAVE_ADDR (tdep, regs, thisreg));
1292 }
1293 else
1294 tag = 3; /* Empty */
1295
1296 ftag |= tag << (2 * fpreg);
1297 }
1298 val[0] = ftag & 0xff;
1299 val[1] = (ftag >> 8) & 0xff;
1300 }
1301 regcache_raw_supply (regcache, i, val);
1302 }
1303 else
1304 regcache_raw_supply (regcache, i, FXSAVE_ADDR (tdep, regs, i));
1305 }
1306
1307 if (regnum == I387_MXCSR_REGNUM (tdep) || regnum == -1)
1308 regcache_raw_supply (regcache, I387_MXCSR_REGNUM (tdep),
1309 FXSAVE_MXCSR_ADDR (regs));
1310 }
1311
1312 /* Similar to i387_collect_fxsave, but use XSAVE extended state. */
1313
1314 void
1315 i387_collect_xsave (const struct regcache *regcache, int regnum,
1316 void *xsave, int gcore)
1317 {
1318 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1319 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1320 gdb_byte *regs = (gdb_byte *) xsave;
1321 int i;
1322 enum
1323 {
1324 none = 0x0,
1325 check = 0x1,
1326 x87 = 0x2 | check,
1327 sse = 0x4 | check,
1328 avxh = 0x8 | check,
1329 mpx = 0x10 | check,
1330 avx512_k = 0x20 | check,
1331 avx512_zmm_h = 0x40 | check,
1332 avx512_ymmh_avx512 = 0x80 | check,
1333 avx512_xmm_avx512 = 0x100 | check,
1334 pkeys = 0x200 | check,
1335 all = x87 | sse | avxh | mpx | avx512_k | avx512_zmm_h
1336 | avx512_ymmh_avx512 | avx512_xmm_avx512 | pkeys
1337 } regclass;
1338
1339 gdb_assert (tdep->st0_regnum >= I386_ST0_REGNUM);
1340 gdb_assert (tdep->num_xmm_regs > 0);
1341
1342 if (regnum == -1)
1343 regclass = all;
1344 else if (regnum >= I387_PKRU_REGNUM (tdep)
1345 && regnum < I387_PKEYSEND_REGNUM (tdep))
1346 regclass = pkeys;
1347 else if (regnum >= I387_ZMM0H_REGNUM (tdep)
1348 && regnum < I387_ZMMENDH_REGNUM (tdep))
1349 regclass = avx512_zmm_h;
1350 else if (regnum >= I387_K0_REGNUM (tdep)
1351 && regnum < I387_KEND_REGNUM (tdep))
1352 regclass = avx512_k;
1353 else if (regnum >= I387_YMM16H_REGNUM (tdep)
1354 && regnum < I387_YMMH_AVX512_END_REGNUM (tdep))
1355 regclass = avx512_ymmh_avx512;
1356 else if (regnum >= I387_XMM16_REGNUM (tdep)
1357 && regnum < I387_XMM_AVX512_END_REGNUM (tdep))
1358 regclass = avx512_xmm_avx512;
1359 else if (regnum >= I387_YMM0H_REGNUM (tdep)
1360 && regnum < I387_YMMENDH_REGNUM (tdep))
1361 regclass = avxh;
1362 else if (regnum >= I387_BND0R_REGNUM (tdep)
1363 && regnum < I387_MPXEND_REGNUM (tdep))
1364 regclass = mpx;
1365 else if (regnum >= I387_XMM0_REGNUM (tdep)
1366 && regnum < I387_MXCSR_REGNUM (tdep))
1367 regclass = sse;
1368 else if (regnum >= I387_ST0_REGNUM (tdep)
1369 && regnum < I387_FCTRL_REGNUM (tdep))
1370 regclass = x87;
1371 else
1372 regclass = none;
1373
1374 if (gcore)
1375 {
1376 /* Clear XSAVE extended state. */
1377 memset (regs, 0, X86_XSTATE_SIZE (tdep->xcr0));
1378
1379 /* Update XCR0 and `xstate_bv' with XCR0 for gcore. */
1380 if (tdep->xsave_xcr0_offset != -1)
1381 memcpy (regs + tdep->xsave_xcr0_offset, &tdep->xcr0, 8);
1382 memcpy (XSAVE_XSTATE_BV_ADDR (regs), &tdep->xcr0, 8);
1383 }
1384
1385 if ((regclass & check))
1386 {
1387 gdb_byte raw[I386_MAX_REGISTER_SIZE];
1388 ULONGEST initial_xstate_bv, clear_bv, xstate_bv = 0;
1389 gdb_byte *p;
1390 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1391
1392 /* The supported bits in `xstat_bv' are 8 bytes. */
1393 initial_xstate_bv = extract_unsigned_integer (XSAVE_XSTATE_BV_ADDR (regs),
1394 8, byte_order);
1395 clear_bv = (~(initial_xstate_bv)) & tdep->xcr0;
1396
1397 /* Clear register set if its bit in xstat_bv is zero. */
1398 if (clear_bv)
1399 {
1400 if ((clear_bv & X86_XSTATE_PKRU))
1401 for (i = I387_PKRU_REGNUM (tdep);
1402 i < I387_PKEYSEND_REGNUM (tdep); i++)
1403 memset (XSAVE_PKEYS_ADDR (tdep, regs, i), 0, 4);
1404
1405 if ((clear_bv & X86_XSTATE_BNDREGS))
1406 for (i = I387_BND0R_REGNUM (tdep);
1407 i < I387_BNDCFGU_REGNUM (tdep); i++)
1408 memset (XSAVE_MPX_ADDR (tdep, regs, i), 0, 16);
1409
1410 if ((clear_bv & X86_XSTATE_BNDCFG))
1411 for (i = I387_BNDCFGU_REGNUM (tdep);
1412 i < I387_MPXEND_REGNUM (tdep); i++)
1413 memset (XSAVE_MPX_ADDR (tdep, regs, i), 0, 8);
1414
1415 if ((clear_bv & (X86_XSTATE_ZMM_H | X86_XSTATE_ZMM)))
1416 for (i = I387_ZMM0H_REGNUM (tdep);
1417 i < I387_ZMMENDH_REGNUM (tdep); i++)
1418 memset (XSAVE_AVX512_ZMM_H_ADDR (tdep, regs, i), 0, 32);
1419
1420 if ((clear_bv & X86_XSTATE_K))
1421 for (i = I387_K0_REGNUM (tdep);
1422 i < I387_KEND_REGNUM (tdep); i++)
1423 memset (XSAVE_AVX512_K_ADDR (tdep, regs, i), 0, 8);
1424
1425 if ((clear_bv & X86_XSTATE_ZMM))
1426 {
1427 for (i = I387_YMM16H_REGNUM (tdep);
1428 i < I387_YMMH_AVX512_END_REGNUM (tdep); i++)
1429 memset (XSAVE_YMM_AVX512_ADDR (tdep, regs, i), 0, 16);
1430 for (i = I387_XMM16_REGNUM (tdep);
1431 i < I387_XMM_AVX512_END_REGNUM (tdep); i++)
1432 memset (XSAVE_XMM_AVX512_ADDR (tdep, regs, i), 0, 16);
1433 }
1434
1435 if ((clear_bv & X86_XSTATE_AVX))
1436 for (i = I387_YMM0H_REGNUM (tdep);
1437 i < I387_YMMENDH_REGNUM (tdep); i++)
1438 memset (XSAVE_AVXH_ADDR (tdep, regs, i), 0, 16);
1439
1440 if ((clear_bv & X86_XSTATE_SSE))
1441 for (i = I387_XMM0_REGNUM (tdep);
1442 i < I387_MXCSR_REGNUM (tdep); i++)
1443 memset (FXSAVE_ADDR (tdep, regs, i), 0, 16);
1444
1445 if ((clear_bv & X86_XSTATE_X87))
1446 for (i = I387_ST0_REGNUM (tdep);
1447 i < I387_FCTRL_REGNUM (tdep); i++)
1448 memset (FXSAVE_ADDR (tdep, regs, i), 0, 10);
1449 }
1450
1451 if (regclass == all)
1452 {
1453 /* Check if any PKEYS registers are changed. */
1454 if ((tdep->xcr0 & X86_XSTATE_PKRU))
1455 for (i = I387_PKRU_REGNUM (tdep);
1456 i < I387_PKEYSEND_REGNUM (tdep); i++)
1457 {
1458 regcache_raw_collect (regcache, i, raw);
1459 p = XSAVE_PKEYS_ADDR (tdep, regs, i);
1460 if (memcmp (raw, p, 4) != 0)
1461 {
1462 xstate_bv |= X86_XSTATE_PKRU;
1463 memcpy (p, raw, 4);
1464 }
1465 }
1466
1467 /* Check if any ZMMH registers are changed. */
1468 if ((tdep->xcr0 & (X86_XSTATE_ZMM_H | X86_XSTATE_ZMM)))
1469 for (i = I387_ZMM0H_REGNUM (tdep);
1470 i < I387_ZMMENDH_REGNUM (tdep); i++)
1471 {
1472 regcache_raw_collect (regcache, i, raw);
1473 p = XSAVE_AVX512_ZMM_H_ADDR (tdep, regs, i);
1474 if (memcmp (raw, p, 32) != 0)
1475 {
1476 xstate_bv |= (X86_XSTATE_ZMM_H | X86_XSTATE_ZMM);
1477 memcpy (p, raw, 32);
1478 }
1479 }
1480
1481 /* Check if any K registers are changed. */
1482 if ((tdep->xcr0 & X86_XSTATE_K))
1483 for (i = I387_K0_REGNUM (tdep);
1484 i < I387_KEND_REGNUM (tdep); i++)
1485 {
1486 regcache_raw_collect (regcache, i, raw);
1487 p = XSAVE_AVX512_K_ADDR (tdep, regs, i);
1488 if (memcmp (raw, p, 8) != 0)
1489 {
1490 xstate_bv |= X86_XSTATE_K;
1491 memcpy (p, raw, 8);
1492 }
1493 }
1494
1495 /* Check if any XMM or upper YMM registers are changed. */
1496 if ((tdep->xcr0 & X86_XSTATE_ZMM))
1497 {
1498 for (i = I387_YMM16H_REGNUM (tdep);
1499 i < I387_YMMH_AVX512_END_REGNUM (tdep); i++)
1500 {
1501 regcache_raw_collect (regcache, i, raw);
1502 p = XSAVE_YMM_AVX512_ADDR (tdep, regs, i);
1503 if (memcmp (raw, p, 16) != 0)
1504 {
1505 xstate_bv |= X86_XSTATE_ZMM;
1506 memcpy (p, raw, 16);
1507 }
1508 }
1509 for (i = I387_XMM16_REGNUM (tdep);
1510 i < I387_XMM_AVX512_END_REGNUM (tdep); i++)
1511 {
1512 regcache_raw_collect (regcache, i, raw);
1513 p = XSAVE_XMM_AVX512_ADDR (tdep, regs, i);
1514 if (memcmp (raw, p, 16) != 0)
1515 {
1516 xstate_bv |= X86_XSTATE_ZMM;
1517 memcpy (p, raw, 16);
1518 }
1519 }
1520 }
1521
1522 /* Check if any upper YMM registers are changed. */
1523 if ((tdep->xcr0 & X86_XSTATE_AVX))
1524 for (i = I387_YMM0H_REGNUM (tdep);
1525 i < I387_YMMENDH_REGNUM (tdep); i++)
1526 {
1527 regcache_raw_collect (regcache, i, raw);
1528 p = XSAVE_AVXH_ADDR (tdep, regs, i);
1529 if (memcmp (raw, p, 16))
1530 {
1531 xstate_bv |= X86_XSTATE_AVX;
1532 memcpy (p, raw, 16);
1533 }
1534 }
1535 /* Check if any upper MPX registers are changed. */
1536 if ((tdep->xcr0 & X86_XSTATE_BNDREGS))
1537 for (i = I387_BND0R_REGNUM (tdep);
1538 i < I387_BNDCFGU_REGNUM (tdep); i++)
1539 {
1540 regcache_raw_collect (regcache, i, raw);
1541 p = XSAVE_MPX_ADDR (tdep, regs, i);
1542 if (memcmp (raw, p, 16))
1543 {
1544 xstate_bv |= X86_XSTATE_BNDREGS;
1545 memcpy (p, raw, 16);
1546 }
1547 }
1548
1549 /* Check if any upper MPX registers are changed. */
1550 if ((tdep->xcr0 & X86_XSTATE_BNDCFG))
1551 for (i = I387_BNDCFGU_REGNUM (tdep);
1552 i < I387_MPXEND_REGNUM (tdep); i++)
1553 {
1554 regcache_raw_collect (regcache, i, raw);
1555 p = XSAVE_MPX_ADDR (tdep, regs, i);
1556 if (memcmp (raw, p, 8))
1557 {
1558 xstate_bv |= X86_XSTATE_BNDCFG;
1559 memcpy (p, raw, 8);
1560 }
1561 }
1562
1563 /* Check if any SSE registers are changed. */
1564 if ((tdep->xcr0 & X86_XSTATE_SSE))
1565 for (i = I387_XMM0_REGNUM (tdep);
1566 i < I387_MXCSR_REGNUM (tdep); i++)
1567 {
1568 regcache_raw_collect (regcache, i, raw);
1569 p = FXSAVE_ADDR (tdep, regs, i);
1570 if (memcmp (raw, p, 16))
1571 {
1572 xstate_bv |= X86_XSTATE_SSE;
1573 memcpy (p, raw, 16);
1574 }
1575 }
1576
1577 /* Check if any X87 registers are changed. */
1578 if ((tdep->xcr0 & X86_XSTATE_X87))
1579 for (i = I387_ST0_REGNUM (tdep);
1580 i < I387_FCTRL_REGNUM (tdep); i++)
1581 {
1582 regcache_raw_collect (regcache, i, raw);
1583 p = FXSAVE_ADDR (tdep, regs, i);
1584 if (memcmp (raw, p, 10))
1585 {
1586 xstate_bv |= X86_XSTATE_X87;
1587 memcpy (p, raw, 10);
1588 }
1589 }
1590 }
1591 else
1592 {
1593 /* Check if REGNUM is changed. */
1594 regcache_raw_collect (regcache, regnum, raw);
1595
1596 switch (regclass)
1597 {
1598 default:
1599 internal_error (__FILE__, __LINE__,
1600 _("invalid i387 regclass"));
1601
1602 case pkeys:
1603 /* This is a PKEYS register. */
1604 p = XSAVE_PKEYS_ADDR (tdep, regs, regnum);
1605 if (memcmp (raw, p, 4) != 0)
1606 {
1607 xstate_bv |= X86_XSTATE_PKRU;
1608 memcpy (p, raw, 4);
1609 }
1610 break;
1611
1612 case avx512_zmm_h:
1613 /* This is a ZMM register. */
1614 p = XSAVE_AVX512_ZMM_H_ADDR (tdep, regs, regnum);
1615 if (memcmp (raw, p, 32) != 0)
1616 {
1617 xstate_bv |= (X86_XSTATE_ZMM_H | X86_XSTATE_ZMM);
1618 memcpy (p, raw, 32);
1619 }
1620 break;
1621 case avx512_k:
1622 /* This is a AVX512 mask register. */
1623 p = XSAVE_AVX512_K_ADDR (tdep, regs, regnum);
1624 if (memcmp (raw, p, 8) != 0)
1625 {
1626 xstate_bv |= X86_XSTATE_K;
1627 memcpy (p, raw, 8);
1628 }
1629 break;
1630
1631 case avx512_ymmh_avx512:
1632 /* This is an upper YMM16-31 register. */
1633 p = XSAVE_YMM_AVX512_ADDR (tdep, regs, regnum);
1634 if (memcmp (raw, p, 16) != 0)
1635 {
1636 xstate_bv |= X86_XSTATE_ZMM;
1637 memcpy (p, raw, 16);
1638 }
1639 break;
1640
1641 case avx512_xmm_avx512:
1642 /* This is an upper XMM16-31 register. */
1643 p = XSAVE_XMM_AVX512_ADDR (tdep, regs, regnum);
1644 if (memcmp (raw, p, 16) != 0)
1645 {
1646 xstate_bv |= X86_XSTATE_ZMM;
1647 memcpy (p, raw, 16);
1648 }
1649 break;
1650
1651 case avxh:
1652 /* This is an upper YMM register. */
1653 p = XSAVE_AVXH_ADDR (tdep, regs, regnum);
1654 if (memcmp (raw, p, 16))
1655 {
1656 xstate_bv |= X86_XSTATE_AVX;
1657 memcpy (p, raw, 16);
1658 }
1659 break;
1660
1661 case mpx:
1662 if (regnum < I387_BNDCFGU_REGNUM (tdep))
1663 {
1664 regcache_raw_collect (regcache, regnum, raw);
1665 p = XSAVE_MPX_ADDR (tdep, regs, regnum);
1666 if (memcmp (raw, p, 16))
1667 {
1668 xstate_bv |= X86_XSTATE_BNDREGS;
1669 memcpy (p, raw, 16);
1670 }
1671 }
1672 else
1673 {
1674 p = XSAVE_MPX_ADDR (tdep, regs, regnum);
1675 xstate_bv |= X86_XSTATE_BNDCFG;
1676 memcpy (p, raw, 8);
1677 }
1678 break;
1679
1680 case sse:
1681 /* This is an SSE register. */
1682 p = FXSAVE_ADDR (tdep, regs, regnum);
1683 if (memcmp (raw, p, 16))
1684 {
1685 xstate_bv |= X86_XSTATE_SSE;
1686 memcpy (p, raw, 16);
1687 }
1688 break;
1689
1690 case x87:
1691 /* This is an x87 register. */
1692 p = FXSAVE_ADDR (tdep, regs, regnum);
1693 if (memcmp (raw, p, 10))
1694 {
1695 xstate_bv |= X86_XSTATE_X87;
1696 memcpy (p, raw, 10);
1697 }
1698 break;
1699 }
1700 }
1701
1702 /* Update the corresponding bits in `xstate_bv' if any SSE/AVX
1703 registers are changed. */
1704 if (xstate_bv)
1705 {
1706 /* The supported bits in `xstat_bv' are 8 bytes. */
1707 initial_xstate_bv |= xstate_bv;
1708 store_unsigned_integer (XSAVE_XSTATE_BV_ADDR (regs),
1709 8, byte_order,
1710 initial_xstate_bv);
1711
1712 switch (regclass)
1713 {
1714 default:
1715 internal_error (__FILE__, __LINE__,
1716 _("invalid i387 regclass"));
1717
1718 case all:
1719 break;
1720
1721 case x87:
1722 case sse:
1723 case avxh:
1724 case mpx:
1725 case avx512_k:
1726 case avx512_zmm_h:
1727 case avx512_ymmh_avx512:
1728 case avx512_xmm_avx512:
1729 case pkeys:
1730 /* Register REGNUM has been updated. Return. */
1731 return;
1732 }
1733 }
1734 else
1735 {
1736 /* Return if REGNUM isn't changed. */
1737 if (regclass != all)
1738 return;
1739 }
1740 }
1741
1742 /* Only handle x87 control registers. */
1743 for (i = I387_FCTRL_REGNUM (tdep); i < I387_XMM0_REGNUM (tdep); i++)
1744 if (regnum == -1 || regnum == i)
1745 {
1746 /* Most of the FPU control registers occupy only 16 bits in
1747 the xsave extended state. Give those a special treatment. */
1748 if (i != I387_FIOFF_REGNUM (tdep)
1749 && i != I387_FOOFF_REGNUM (tdep))
1750 {
1751 gdb_byte buf[4];
1752
1753 regcache_raw_collect (regcache, i, buf);
1754
1755 if (i == I387_FOP_REGNUM (tdep))
1756 {
1757 /* The opcode occupies only 11 bits. Make sure we
1758 don't touch the other bits. */
1759 buf[1] &= ((1 << 3) - 1);
1760 buf[1] |= ((FXSAVE_ADDR (tdep, regs, i))[1] & ~((1 << 3) - 1));
1761 }
1762 else if (i == I387_FTAG_REGNUM (tdep))
1763 {
1764 /* Converting back is much easier. */
1765
1766 unsigned short ftag;
1767 int fpreg;
1768
1769 ftag = (buf[1] << 8) | buf[0];
1770 buf[0] = 0;
1771 buf[1] = 0;
1772
1773 for (fpreg = 7; fpreg >= 0; fpreg--)
1774 {
1775 int tag = (ftag >> (fpreg * 2)) & 3;
1776
1777 if (tag != 3)
1778 buf[0] |= (1 << fpreg);
1779 }
1780 }
1781 memcpy (FXSAVE_ADDR (tdep, regs, i), buf, 2);
1782 }
1783 else
1784 regcache_raw_collect (regcache, i, FXSAVE_ADDR (tdep, regs, i));
1785 }
1786
1787 if (regnum == I387_MXCSR_REGNUM (tdep) || regnum == -1)
1788 regcache_raw_collect (regcache, I387_MXCSR_REGNUM (tdep),
1789 FXSAVE_MXCSR_ADDR (regs));
1790 }
1791
1792 /* Recreate the FTW (tag word) valid bits from the 80-bit FP data in
1793 *RAW. */
1794
1795 static int
1796 i387_tag (const gdb_byte *raw)
1797 {
1798 int integer;
1799 unsigned int exponent;
1800 unsigned long fraction[2];
1801
1802 integer = raw[7] & 0x80;
1803 exponent = (((raw[9] & 0x7f) << 8) | raw[8]);
1804 fraction[0] = ((raw[3] << 24) | (raw[2] << 16) | (raw[1] << 8) | raw[0]);
1805 fraction[1] = (((raw[7] & 0x7f) << 24) | (raw[6] << 16)
1806 | (raw[5] << 8) | raw[4]);
1807
1808 if (exponent == 0x7fff)
1809 {
1810 /* Special. */
1811 return (2);
1812 }
1813 else if (exponent == 0x0000)
1814 {
1815 if (fraction[0] == 0x0000 && fraction[1] == 0x0000 && !integer)
1816 {
1817 /* Zero. */
1818 return (1);
1819 }
1820 else
1821 {
1822 /* Special. */
1823 return (2);
1824 }
1825 }
1826 else
1827 {
1828 if (integer)
1829 {
1830 /* Valid. */
1831 return (0);
1832 }
1833 else
1834 {
1835 /* Special. */
1836 return (2);
1837 }
1838 }
1839 }
1840
1841 /* Prepare the FPU stack in REGCACHE for a function return. */
1842
1843 void
1844 i387_return_value (struct gdbarch *gdbarch, struct regcache *regcache)
1845 {
1846 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1847 ULONGEST fstat;
1848
1849 /* Set the top of the floating-point register stack to 7. The
1850 actual value doesn't really matter, but 7 is what a normal
1851 function return would end up with if the program started out with
1852 a freshly initialized FPU. */
1853 regcache_raw_read_unsigned (regcache, I387_FSTAT_REGNUM (tdep), &fstat);
1854 fstat |= (7 << 11);
1855 regcache_raw_write_unsigned (regcache, I387_FSTAT_REGNUM (tdep), fstat);
1856
1857 /* Mark %st(1) through %st(7) as empty. Since we set the top of the
1858 floating-point register stack to 7, the appropriate value for the
1859 tag word is 0x3fff. */
1860 regcache_raw_write_unsigned (regcache, I387_FTAG_REGNUM (tdep), 0x3fff);
1861
1862 }
1863
1864 /* See i387-tdep.h. */
1865
1866 void
1867 i387_reset_bnd_regs (struct gdbarch *gdbarch, struct regcache *regcache)
1868 {
1869 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1870
1871 if (I387_BND0R_REGNUM (tdep) > 0)
1872 {
1873 gdb_byte bnd_buf[16];
1874
1875 memset (bnd_buf, 0, 16);
1876 for (int i = 0; i < I387_NUM_BND_REGS; i++)
1877 regcache_raw_write (regcache, I387_BND0R_REGNUM (tdep) + i, bnd_buf);
1878 }
1879 }
GDB Binutils - Deliverables
This page took 0.091211 seconds and 3 git commands to generate.