gdbserver/i387-fp.cc

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