a90729ae254902848b7dc738249e5505c0c7b3b6
[external/binutils.git] / gdb / gdbserver / i387-fp.c
1 /* i387-specific utility functions, for the remote server for GDB.
2    Copyright (C) 2000-2016 Free Software Foundation, Inc.
3
4    This file is part of GDB.
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
18
19 #include "server.h"
20 #include "i387-fp.h"
21 #include "x86-xstate.h"
22
23 static const int num_mpx_bnd_registers = 4;
24 static const int num_mpx_cfg_registers = 2;
25 static const int num_avx512_k_registers = 8;
26 static const int num_avx512_zmmh_low_registers = 16;
27 static const int num_avx512_zmmh_high_registers = 16;
28 static const int num_avx512_ymmh_registers = 16;
29 static const int num_avx512_xmm_registers = 16;
30
31 /* Note: These functions preserve the reserved bits in control registers.
32    However, gdbserver promptly throws away that information.  */
33
34 /* These structs should have the proper sizes and alignment on both
35    i386 and x86-64 machines.  */
36
37 struct i387_fsave {
38   /* All these are only sixteen bits, plus padding, except for fop (which
39      is only eleven bits), and fooff / fioff (which are 32 bits each).  */
40   unsigned short fctrl;
41   unsigned short pad1;
42   unsigned short fstat;
43   unsigned short pad2;
44   unsigned short ftag;
45   unsigned short pad3;
46   unsigned int fioff;
47   unsigned short fiseg;
48   unsigned short fop;
49   unsigned int fooff;
50   unsigned short foseg;
51   unsigned short pad4;
52
53   /* Space for eight 80-bit FP values.  */
54   unsigned char st_space[80];
55 };
56
57 struct i387_fxsave {
58   /* All these are only sixteen bits, plus padding, except for fop (which
59      is only eleven bits), and fooff / fioff (which are 32 bits each).  */
60   unsigned short fctrl;
61   unsigned short fstat;
62   unsigned short ftag;
63   unsigned short fop;
64   unsigned int fioff;
65   unsigned short fiseg;
66   unsigned short pad1;
67   unsigned int fooff;
68   unsigned short foseg;
69   unsigned short pad12;
70
71   unsigned int mxcsr;
72   unsigned int pad3;
73
74   /* Space for eight 80-bit FP values in 128-bit spaces.  */
75   unsigned char st_space[128];
76
77   /* Space for eight 128-bit XMM values, or 16 on x86-64.  */
78   unsigned char xmm_space[256];
79 };
80
81 struct i387_xsave {
82   /* All these are only sixteen bits, plus padding, except for fop (which
83      is only eleven bits), and fooff / fioff (which are 32 bits each).  */
84   unsigned short fctrl;
85   unsigned short fstat;
86   unsigned short ftag;
87   unsigned short fop;
88   unsigned int fioff;
89   unsigned short fiseg;
90   unsigned short pad1;
91   unsigned int fooff;
92   unsigned short foseg;
93   unsigned short pad12;
94
95   unsigned int mxcsr;
96   unsigned int mxcsr_mask;
97
98   /* Space for eight 80-bit FP values in 128-bit spaces.  */
99   unsigned char st_space[128];
100
101   /* Space for eight 128-bit XMM values, or 16 on x86-64.  */
102   unsigned char xmm_space[256];
103
104   unsigned char reserved1[48];
105
106   /* The extended control register 0 (the XFEATURE_ENABLED_MASK
107      register).  */
108   unsigned long long xcr0;
109
110   unsigned char reserved2[40];
111
112   /* The XSTATE_BV bit vector.  */
113   unsigned long long xstate_bv;
114
115   unsigned char reserved3[56];
116
117   /* Space for eight upper 128-bit YMM values, or 16 on x86-64.  */
118   unsigned char ymmh_space[256];
119
120   unsigned char reserved4[128];
121
122   /* Space for 4 bound registers values of 128 bits.  */
123   unsigned char mpx_bnd_space[64];
124
125   /* Space for 2 MPX configuration registers of 64 bits
126      plus reserved space.  */
127   unsigned char mpx_cfg_space[16];
128
129   unsigned char reserved5[48];
130
131   /* Space for 8 OpMask register values of 64 bits.  */
132   unsigned char k_space[64];
133
134   /* Space for 16 256-bit zmm0-15.  */
135   unsigned char zmmh_low_space[512];
136
137   /* Space for 16 512-bit zmm16-31 values.  */
138   unsigned char zmmh_high_space[1024];
139 };
140
141 void
142 i387_cache_to_fsave (struct regcache *regcache, void *buf)
143 {
144   struct i387_fsave *fp = (struct i387_fsave *) buf;
145   int i;
146   int st0_regnum = find_regno (regcache->tdesc, "st0");
147   unsigned long val, val2;
148
149   for (i = 0; i < 8; i++)
150     collect_register (regcache, i + st0_regnum,
151                       ((char *) &fp->st_space[0]) + i * 10);
152
153   collect_register_by_name (regcache, "fioff", &fp->fioff);
154   collect_register_by_name (regcache, "fooff", &fp->fooff);
155   
156   /* This one's 11 bits... */
157   collect_register_by_name (regcache, "fop", &val2);
158   fp->fop = (val2 & 0x7FF) | (fp->fop & 0xF800);
159
160   /* Some registers are 16-bit.  */
161   collect_register_by_name (regcache, "fctrl", &val);
162   fp->fctrl = val;
163
164   collect_register_by_name (regcache, "fstat", &val);
165   val &= 0xFFFF;
166   fp->fstat = val;
167
168   collect_register_by_name (regcache, "ftag", &val);
169   val &= 0xFFFF;
170   fp->ftag = val;
171
172   collect_register_by_name (regcache, "fiseg", &val);
173   val &= 0xFFFF;
174   fp->fiseg = val;
175
176   collect_register_by_name (regcache, "foseg", &val);
177   val &= 0xFFFF;
178   fp->foseg = val;
179 }
180
181 void
182 i387_fsave_to_cache (struct regcache *regcache, const void *buf)
183 {
184   struct i387_fsave *fp = (struct i387_fsave *) buf;
185   int i;
186   int st0_regnum = find_regno (regcache->tdesc, "st0");
187   unsigned long val;
188
189   for (i = 0; i < 8; i++)
190     supply_register (regcache, i + st0_regnum,
191                      ((char *) &fp->st_space[0]) + i * 10);
192
193   supply_register_by_name (regcache, "fioff", &fp->fioff);
194   supply_register_by_name (regcache, "fooff", &fp->fooff);
195
196   /* Some registers are 16-bit.  */
197   val = fp->fctrl & 0xFFFF;
198   supply_register_by_name (regcache, "fctrl", &val);
199
200   val = fp->fstat & 0xFFFF;
201   supply_register_by_name (regcache, "fstat", &val);
202
203   val = fp->ftag & 0xFFFF;
204   supply_register_by_name (regcache, "ftag", &val);
205
206   val = fp->fiseg & 0xFFFF;
207   supply_register_by_name (regcache, "fiseg", &val);
208
209   val = fp->foseg & 0xFFFF;
210   supply_register_by_name (regcache, "foseg", &val);
211
212   /* fop has only 11 valid bits.  */
213   val = (fp->fop) & 0x7FF;
214   supply_register_by_name (regcache, "fop", &val);
215 }
216
217 void
218 i387_cache_to_fxsave (struct regcache *regcache, void *buf)
219 {
220   struct i387_fxsave *fp = (struct i387_fxsave *) buf;
221   int i;
222   int st0_regnum = find_regno (regcache->tdesc, "st0");
223   int xmm0_regnum = find_regno (regcache->tdesc, "xmm0");
224   unsigned long val, val2;
225   /* Amd64 has 16 xmm regs; I386 has 8 xmm regs.  */
226   int num_xmm_registers = register_size (regcache->tdesc, 0) == 8 ? 16 : 8;
227
228   for (i = 0; i < 8; i++)
229     collect_register (regcache, i + st0_regnum,
230                       ((char *) &fp->st_space[0]) + i * 16);
231   for (i = 0; i < num_xmm_registers; i++)
232     collect_register (regcache, i + xmm0_regnum,
233                       ((char *) &fp->xmm_space[0]) + i * 16);
234
235   collect_register_by_name (regcache, "fioff", &fp->fioff);
236   collect_register_by_name (regcache, "fooff", &fp->fooff);
237   collect_register_by_name (regcache, "mxcsr", &fp->mxcsr);
238
239   /* This one's 11 bits... */
240   collect_register_by_name (regcache, "fop", &val2);
241   fp->fop = (val2 & 0x7FF) | (fp->fop & 0xF800);
242
243   /* Some registers are 16-bit.  */
244   collect_register_by_name (regcache, "fctrl", &val);
245   fp->fctrl = val;
246
247   collect_register_by_name (regcache, "fstat", &val);
248   fp->fstat = val;
249
250   /* Convert to the simplifed tag form stored in fxsave data.  */
251   collect_register_by_name (regcache, "ftag", &val);
252   val &= 0xFFFF;
253   val2 = 0;
254   for (i = 7; i >= 0; i--)
255     {
256       int tag = (val >> (i * 2)) & 3;
257
258       if (tag != 3)
259         val2 |= (1 << i);
260     }
261   fp->ftag = val2;
262
263   collect_register_by_name (regcache, "fiseg", &val);
264   fp->fiseg = val;
265
266   collect_register_by_name (regcache, "foseg", &val);
267   fp->foseg = val;
268 }
269
270 void
271 i387_cache_to_xsave (struct regcache *regcache, void *buf)
272 {
273   struct i387_xsave *fp = (struct i387_xsave *) buf;
274   int i;
275   unsigned long val, val2;
276   unsigned int clear_bv;
277   unsigned long long xstate_bv = 0;
278   char raw[64];
279   char *p;
280   /* Amd64 has 16 xmm regs; I386 has 8 xmm regs.  */
281   int num_xmm_registers = register_size (regcache->tdesc, 0) == 8 ? 16 : 8;
282
283   /* The supported bits in `xstat_bv' are 1 byte.  Clear part in
284      vector registers if its bit in xstat_bv is zero.  */
285   clear_bv = (~fp->xstate_bv) & x86_xcr0;
286
287   /* Clear part in x87 and vector registers if its bit in xstat_bv is
288      zero.  */
289   if (clear_bv)
290     {
291       if ((clear_bv & X86_XSTATE_X87))
292         for (i = 0; i < 8; i++)
293           memset (((char *) &fp->st_space[0]) + i * 16, 0, 10);
294
295       if ((clear_bv & X86_XSTATE_SSE))
296         for (i = 0; i < num_xmm_registers; i++) 
297           memset (((char *) &fp->xmm_space[0]) + i * 16, 0, 16);
298
299       if ((clear_bv & X86_XSTATE_AVX))
300         for (i = 0; i < num_xmm_registers; i++) 
301           memset (((char *) &fp->ymmh_space[0]) + i * 16, 0, 16);
302
303       if ((clear_bv & X86_XSTATE_BNDREGS))
304         for (i = 0; i < num_mpx_bnd_registers; i++)
305           memset (((char *) &fp->mpx_bnd_space[0]) + i * 16, 0, 16);
306
307       if ((clear_bv & X86_XSTATE_BNDCFG))
308         for (i = 0; i < num_mpx_cfg_registers; i++)
309           memset (((char *) &fp->mpx_cfg_space[0]) + i * 8, 0, 8);
310
311       if ((clear_bv & X86_XSTATE_K))
312         for (i = 0; i < num_avx512_k_registers; i++)
313           memset (((char *) &fp->k_space[0]) + i * 8, 0, 8);
314
315       if ((clear_bv & X86_XSTATE_ZMM_H))
316         for (i = 0; i < num_avx512_zmmh_low_registers; i++)
317           memset (((char *) &fp->zmmh_low_space[0]) + i * 32, 0, 32);
318
319       if ((clear_bv & X86_XSTATE_ZMM))
320         {
321           for (i = 0; i < num_avx512_zmmh_high_registers; i++)
322             memset (((char *) &fp->zmmh_low_space[0]) + 32 + i * 64, 0, 32);
323           for (i = 0; i < num_avx512_xmm_registers; i++)
324             memset (((char *) &fp->zmmh_high_space[0]) + i * 64, 0, 16);
325           for (i = 0; i < num_avx512_ymmh_registers; i++)
326             memset (((char *) &fp->zmmh_high_space[0]) + 16 + i * 64, 0, 16);
327         }
328     }
329
330   /* Check if any x87 registers are changed.  */
331   if ((x86_xcr0 & X86_XSTATE_X87))
332     {
333       int st0_regnum = find_regno (regcache->tdesc, "st0");
334
335       for (i = 0; i < 8; i++)
336         {
337           collect_register (regcache, i + st0_regnum, raw);
338           p = ((char *) &fp->st_space[0]) + i * 16;
339           if (memcmp (raw, p, 10))
340             {
341               xstate_bv |= X86_XSTATE_X87;
342               memcpy (p, raw, 10);
343             }
344         }
345     }
346
347   /* Check if any SSE registers are changed.  */
348   if ((x86_xcr0 & X86_XSTATE_SSE))
349     {
350       int xmm0_regnum = find_regno (regcache->tdesc, "xmm0");
351
352       for (i = 0; i < num_xmm_registers; i++) 
353         {
354           collect_register (regcache, i + xmm0_regnum, raw);
355           p = ((char *) &fp->xmm_space[0]) + i * 16;
356           if (memcmp (raw, p, 16))
357             {
358               xstate_bv |= X86_XSTATE_SSE;
359               memcpy (p, raw, 16);
360             }
361         }
362     }
363
364   /* Check if any AVX registers are changed.  */
365   if ((x86_xcr0 & X86_XSTATE_AVX))
366     {
367       int ymm0h_regnum = find_regno (regcache->tdesc, "ymm0h");
368
369       for (i = 0; i < num_xmm_registers; i++) 
370         {
371           collect_register (regcache, i + ymm0h_regnum, raw);
372           p = ((char *) &fp->ymmh_space[0]) + i * 16;
373           if (memcmp (raw, p, 16))
374             {
375               xstate_bv |= X86_XSTATE_AVX;
376               memcpy (p, raw, 16);
377             }
378         }
379     }
380
381   /* Check if any bound register has changed.  */
382   if ((x86_xcr0 & X86_XSTATE_BNDREGS))
383     {
384      int bnd0r_regnum = find_regno (regcache->tdesc, "bnd0raw");
385
386       for (i = 0; i < num_mpx_bnd_registers; i++)
387         {
388           collect_register (regcache, i + bnd0r_regnum, raw);
389           p = ((char *) &fp->mpx_bnd_space[0]) + i * 16;
390           if (memcmp (raw, p, 16))
391             {
392               xstate_bv |= X86_XSTATE_BNDREGS;
393               memcpy (p, raw, 16);
394             }
395         }
396     }
397
398   /* Check if any status register has changed.  */
399   if ((x86_xcr0 & X86_XSTATE_BNDCFG))
400     {
401       int bndcfg_regnum = find_regno (regcache->tdesc, "bndcfgu");
402
403       for (i = 0; i < num_mpx_cfg_registers; i++)
404         {
405           collect_register (regcache, i + bndcfg_regnum, raw);
406           p = ((char *) &fp->mpx_cfg_space[0]) + i * 8;
407           if (memcmp (raw, p, 8))
408             {
409               xstate_bv |= X86_XSTATE_BNDCFG;
410               memcpy (p, raw, 8);
411             }
412         }
413     }
414
415   /* Check if any K registers are changed.  */
416   if ((x86_xcr0 & X86_XSTATE_K))
417     {
418       int k0_regnum = find_regno (regcache->tdesc, "k0");
419
420       for (i = 0; i < num_avx512_k_registers; i++)
421         {
422           collect_register (regcache, i + k0_regnum, raw);
423           p = ((char *) &fp->k_space[0]) + i * 8;
424           if (memcmp (raw, p, 8) != 0)
425             {
426               xstate_bv |= X86_XSTATE_K;
427               memcpy (p, raw, 8);
428             }
429         }
430     }
431
432   /* Check if any of ZMM0H-ZMM15H registers are changed.  */
433   if ((x86_xcr0 & X86_XSTATE_ZMM_H))
434     {
435       int zmm0h_regnum = find_regno (regcache->tdesc, "zmm0h");
436
437       for (i = 0; i < num_avx512_zmmh_low_registers; i++)
438         {
439           collect_register (regcache, i + zmm0h_regnum, raw);
440           p = ((char *) &fp->zmmh_low_space[0]) + i * 32;
441           if (memcmp (raw, p, 32) != 0)
442             {
443               xstate_bv |= X86_XSTATE_ZMM_H;
444               memcpy (p, raw, 32);
445             }
446         }
447     }
448
449   /* Check if any of ZMM16H-ZMM31H registers are changed.  */
450   if ((x86_xcr0 & X86_XSTATE_ZMM))
451     {
452       int zmm16h_regnum = find_regno (regcache->tdesc, "zmm16h");
453
454       for (i = 0; i < num_avx512_zmmh_high_registers; i++)
455         {
456           collect_register (regcache, i + zmm16h_regnum, raw);
457           p = ((char *) &fp->zmmh_high_space[0]) + 32 + i * 64;
458           if (memcmp (raw, p, 32) != 0)
459             {
460               xstate_bv |= X86_XSTATE_ZMM;
461               memcpy (p, raw, 32);
462             }
463         }
464     }
465
466   /* Check if any XMM_AVX512 registers are changed.  */
467   if ((x86_xcr0 & X86_XSTATE_ZMM))
468     {
469       int xmm_avx512_regnum = find_regno (regcache->tdesc, "xmm16");
470
471       for (i = 0; i < num_avx512_xmm_registers; i++)
472         {
473           collect_register (regcache, i + xmm_avx512_regnum, raw);
474           p = ((char *) &fp->zmmh_high_space[0]) + i * 64;
475           if (memcmp (raw, p, 16) != 0)
476             {
477               xstate_bv |= X86_XSTATE_ZMM;
478               memcpy (p, raw, 16);
479             }
480         }
481     }
482
483   /* Check if any YMMH_AVX512 registers are changed.  */
484   if ((x86_xcr0 & X86_XSTATE_ZMM))
485     {
486       int ymmh_avx512_regnum = find_regno (regcache->tdesc, "ymm16h");
487
488       for (i = 0; i < num_avx512_ymmh_registers; i++)
489         {
490           collect_register (regcache, i + ymmh_avx512_regnum, raw);
491           p = ((char *) &fp->zmmh_high_space[0]) + 16 + i * 64;
492           if (memcmp (raw, p, 16) != 0)
493             {
494               xstate_bv |= X86_XSTATE_ZMM;
495               memcpy (p, raw, 16);
496             }
497         }
498     }
499
500   /* Update the corresponding bits in xstate_bv if any SSE/AVX
501      registers are changed.  */
502   fp->xstate_bv |= xstate_bv;
503
504   collect_register_by_name (regcache, "fioff", &fp->fioff);
505   collect_register_by_name (regcache, "fooff", &fp->fooff);
506   collect_register_by_name (regcache, "mxcsr", &fp->mxcsr);
507
508   /* This one's 11 bits... */
509   collect_register_by_name (regcache, "fop", &val2);
510   fp->fop = (val2 & 0x7FF) | (fp->fop & 0xF800);
511
512   /* Some registers are 16-bit.  */
513   collect_register_by_name (regcache, "fctrl", &val);
514   fp->fctrl = val;
515
516   collect_register_by_name (regcache, "fstat", &val);
517   fp->fstat = val;
518
519   /* Convert to the simplifed tag form stored in fxsave data.  */
520   collect_register_by_name (regcache, "ftag", &val);
521   val &= 0xFFFF;
522   val2 = 0;
523   for (i = 7; i >= 0; i--)
524     {
525       int tag = (val >> (i * 2)) & 3;
526
527       if (tag != 3)
528         val2 |= (1 << i);
529     }
530   fp->ftag = val2;
531
532   collect_register_by_name (regcache, "fiseg", &val);
533   fp->fiseg = val;
534
535   collect_register_by_name (regcache, "foseg", &val);
536   fp->foseg = val;
537 }
538
539 static int
540 i387_ftag (struct i387_fxsave *fp, int regno)
541 {
542   unsigned char *raw = &fp->st_space[regno * 16];
543   unsigned int exponent;
544   unsigned long fraction[2];
545   int integer;
546
547   integer = raw[7] & 0x80;
548   exponent = (((raw[9] & 0x7f) << 8) | raw[8]);
549   fraction[0] = ((raw[3] << 24) | (raw[2] << 16) | (raw[1] << 8) | raw[0]);
550   fraction[1] = (((raw[7] & 0x7f) << 24) | (raw[6] << 16)
551                  | (raw[5] << 8) | raw[4]);
552
553   if (exponent == 0x7fff)
554     {
555       /* Special.  */
556       return (2);
557     }
558   else if (exponent == 0x0000)
559     {
560       if (fraction[0] == 0x0000 && fraction[1] == 0x0000 && !integer)
561         {
562           /* Zero.  */
563           return (1);
564         }
565       else
566         {
567           /* Special.  */
568           return (2);
569         }
570     }
571   else
572     {
573       if (integer)
574         {
575           /* Valid.  */
576           return (0);
577         }
578       else
579         {
580           /* Special.  */
581           return (2);
582         }
583     }
584 }
585
586 void
587 i387_fxsave_to_cache (struct regcache *regcache, const void *buf)
588 {
589   struct i387_fxsave *fp = (struct i387_fxsave *) buf;
590   int i, top;
591   int st0_regnum = find_regno (regcache->tdesc, "st0");
592   int xmm0_regnum = find_regno (regcache->tdesc, "xmm0");
593   unsigned long val;
594   /* Amd64 has 16 xmm regs; I386 has 8 xmm regs.  */
595   int num_xmm_registers = register_size (regcache->tdesc, 0) == 8 ? 16 : 8;
596
597   for (i = 0; i < 8; i++)
598     supply_register (regcache, i + st0_regnum,
599                      ((char *) &fp->st_space[0]) + i * 16);
600   for (i = 0; i < num_xmm_registers; i++)
601     supply_register (regcache, i + xmm0_regnum,
602                      ((char *) &fp->xmm_space[0]) + i * 16);
603
604   supply_register_by_name (regcache, "fioff", &fp->fioff);
605   supply_register_by_name (regcache, "fooff", &fp->fooff);
606   supply_register_by_name (regcache, "mxcsr", &fp->mxcsr);
607
608   /* Some registers are 16-bit.  */
609   val = fp->fctrl & 0xFFFF;
610   supply_register_by_name (regcache, "fctrl", &val);
611
612   val = fp->fstat & 0xFFFF;
613   supply_register_by_name (regcache, "fstat", &val);
614
615   /* Generate the form of ftag data that GDB expects.  */
616   top = (fp->fstat >> 11) & 0x7;
617   val = 0;
618   for (i = 7; i >= 0; i--)
619     {
620       int tag;
621       if (fp->ftag & (1 << i))
622         tag = i387_ftag (fp, (i + 8 - top) % 8);
623       else
624         tag = 3;
625       val |= tag << (2 * i);
626     }
627   supply_register_by_name (regcache, "ftag", &val);
628
629   val = fp->fiseg & 0xFFFF;
630   supply_register_by_name (regcache, "fiseg", &val);
631
632   val = fp->foseg & 0xFFFF;
633   supply_register_by_name (regcache, "foseg", &val);
634
635   val = (fp->fop) & 0x7FF;
636   supply_register_by_name (regcache, "fop", &val);
637 }
638
639 void
640 i387_xsave_to_cache (struct regcache *regcache, const void *buf)
641 {
642   struct i387_xsave *fp = (struct i387_xsave *) buf;
643   struct i387_fxsave *fxp = (struct i387_fxsave *) buf;
644   int i, top;
645   unsigned long val;
646   unsigned int clear_bv;
647   gdb_byte *p;
648   /* Amd64 has 16 xmm regs; I386 has 8 xmm regs.  */
649   int num_xmm_registers = register_size (regcache->tdesc, 0) == 8 ? 16 : 8;
650
651   /* The supported bits in `xstat_bv' are 1 byte.  Clear part in
652      vector registers if its bit in xstat_bv is zero.  */
653   clear_bv = (~fp->xstate_bv) & x86_xcr0;
654
655   /* Check if any x87 registers are changed.  */
656   if ((x86_xcr0 & X86_XSTATE_X87) != 0)
657     {
658       int st0_regnum = find_regno (regcache->tdesc, "st0");
659
660       if ((clear_bv & X86_XSTATE_X87) != 0)
661         {
662           for (i = 0; i < 8; i++)
663             supply_register_zeroed (regcache, i + st0_regnum);
664         }
665       else
666         {
667           p = (gdb_byte *) &fp->st_space[0];
668           for (i = 0; i < 8; i++)
669             supply_register (regcache, i + st0_regnum, p + i * 16);
670         }
671     }
672
673   if ((x86_xcr0 & X86_XSTATE_SSE) != 0)
674     {
675       int xmm0_regnum = find_regno (regcache->tdesc, "xmm0");
676
677       if ((clear_bv & X86_XSTATE_SSE))
678         {
679           for (i = 0; i < num_xmm_registers; i++)
680             supply_register_zeroed (regcache, i + xmm0_regnum);
681         }
682       else
683         {
684           p = (gdb_byte *) &fp->xmm_space[0];
685           for (i = 0; i < num_xmm_registers; i++)
686             supply_register (regcache, i + xmm0_regnum, p + i * 16);
687         }
688     }
689
690   if ((x86_xcr0 & X86_XSTATE_AVX) != 0)
691     {
692       int ymm0h_regnum = find_regno (regcache->tdesc, "ymm0h");
693
694       if ((clear_bv & X86_XSTATE_AVX) != 0)
695         {
696           for (i = 0; i < num_xmm_registers; i++)
697             supply_register_zeroed (regcache, i + ymm0h_regnum);
698         }
699       else
700         {
701           p = (gdb_byte *) &fp->ymmh_space[0];
702           for (i = 0; i < num_xmm_registers; i++)
703             supply_register (regcache, i + ymm0h_regnum, p + i * 16);
704         }
705     }
706
707   if ((x86_xcr0 & X86_XSTATE_BNDREGS))
708     {
709       int bnd0r_regnum = find_regno (regcache->tdesc, "bnd0raw");
710
711
712       if ((clear_bv & X86_XSTATE_BNDREGS) != 0)
713         {
714           for (i = 0; i < num_mpx_bnd_registers; i++)
715             supply_register_zeroed (regcache, i + bnd0r_regnum);
716         }
717       else
718         {
719           p = (gdb_byte *) &fp->mpx_bnd_space[0];
720           for (i = 0; i < num_mpx_bnd_registers; i++)
721             supply_register (regcache, i + bnd0r_regnum, p + i * 16);
722         }
723
724     }
725
726   if ((x86_xcr0 & X86_XSTATE_BNDCFG))
727     {
728       int bndcfg_regnum = find_regno (regcache->tdesc, "bndcfgu");
729
730       if ((clear_bv & X86_XSTATE_BNDCFG) != 0)
731         {
732           for (i = 0; i < num_mpx_cfg_registers; i++)
733             supply_register_zeroed (regcache, i + bndcfg_regnum);
734         }
735       else
736         {
737           p = (gdb_byte *) &fp->mpx_cfg_space[0];
738           for (i = 0; i < num_mpx_cfg_registers; i++)
739             supply_register (regcache, i + bndcfg_regnum, p + i * 8);
740         }
741     }
742
743   if ((x86_xcr0 & X86_XSTATE_K) != 0)
744     {
745       int k0_regnum = find_regno (regcache->tdesc, "k0");
746
747       if ((clear_bv & X86_XSTATE_K) != 0)
748         {
749           for (i = 0; i < num_avx512_k_registers; i++)
750             supply_register_zeroed (regcache, i + k0_regnum);
751         }
752       else
753         {
754           p = (gdb_byte *) &fp->k_space[0];
755           for (i = 0; i < num_avx512_k_registers; i++)
756             supply_register (regcache, i + k0_regnum, p + i * 8);
757         }
758     }
759
760   if ((x86_xcr0 & X86_XSTATE_ZMM_H) != 0)
761     {
762       int zmm0h_regnum = find_regno (regcache->tdesc, "zmm0h");
763
764       if ((clear_bv & X86_XSTATE_ZMM_H) != 0)
765         {
766           for (i = 0; i < num_avx512_zmmh_low_registers; i++)
767             supply_register_zeroed (regcache, i + zmm0h_regnum);
768         }
769       else
770         {
771           p = (gdb_byte *) &fp->zmmh_low_space[0];
772           for (i = 0; i < num_avx512_zmmh_low_registers; i++)
773             supply_register (regcache, i + zmm0h_regnum, p + i * 32);
774         }
775     }
776
777   if ((x86_xcr0 & X86_XSTATE_ZMM) != 0)
778     {
779       int zmm16h_regnum = find_regno (regcache->tdesc, "zmm16h");
780       int ymm16h_regnum = find_regno (regcache->tdesc, "ymm16h");
781       int xmm16_regnum = find_regno (regcache->tdesc, "xmm16");
782
783       if ((clear_bv & X86_XSTATE_ZMM) != 0)
784         {
785           for (i = 0; i < num_avx512_zmmh_high_registers; i++)
786             supply_register_zeroed (regcache, i + zmm16h_regnum);
787           for (i = 0; i < num_avx512_ymmh_registers; i++)
788             supply_register_zeroed (regcache, i + ymm16h_regnum);
789           for (i = 0; i < num_avx512_xmm_registers; i++)
790             supply_register_zeroed (regcache, i + xmm16_regnum);
791         }
792       else
793         {
794           p = (gdb_byte *) &fp->zmmh_high_space[0];
795           for (i = 0; i < num_avx512_zmmh_high_registers; i++)
796             supply_register (regcache, i + zmm16h_regnum, p + 32 + i * 64);
797           for (i = 0; i < num_avx512_ymmh_registers; i++)
798             supply_register (regcache, i + ymm16h_regnum, p + 16 + i * 64);
799           for (i = 0; i < num_avx512_xmm_registers; i++)
800             supply_register (regcache, i + xmm16_regnum, p + i * 64);
801         }
802     }
803
804   supply_register_by_name (regcache, "fioff", &fp->fioff);
805   supply_register_by_name (regcache, "fooff", &fp->fooff);
806   supply_register_by_name (regcache, "mxcsr", &fp->mxcsr);
807
808   /* Some registers are 16-bit.  */
809   val = fp->fctrl & 0xFFFF;
810   supply_register_by_name (regcache, "fctrl", &val);
811
812   val = fp->fstat & 0xFFFF;
813   supply_register_by_name (regcache, "fstat", &val);
814
815   /* Generate the form of ftag data that GDB expects.  */
816   top = (fp->fstat >> 11) & 0x7;
817   val = 0;
818   for (i = 7; i >= 0; i--)
819     {
820       int tag;
821       if (fp->ftag & (1 << i))
822         tag = i387_ftag (fxp, (i + 8 - top) % 8);
823       else
824         tag = 3;
825       val |= tag << (2 * i);
826     }
827   supply_register_by_name (regcache, "ftag", &val);
828
829   val = fp->fiseg & 0xFFFF;
830   supply_register_by_name (regcache, "fiseg", &val);
831
832   val = fp->foseg & 0xFFFF;
833   supply_register_by_name (regcache, "foseg", &val);
834
835   val = (fp->fop) & 0x7FF;
836   supply_register_by_name (regcache, "fop", &val);
837 }
838
839 /* Default to SSE.  */
840 unsigned long long x86_xcr0 = X86_XSTATE_SSE_MASK;