gdb: add target_ops::supports_displaced_step

[deliverable/binutils-gdb.git] / gdb / i387-tdep.c

diff --git a/gdb/i387-tdep.c b/gdb/i387-tdep.c
index aca70c186f930fd53dfea1f1272ab33d74d80d27..b8c342d22aaee73f8fea66b87d322b2e40c6e69d 100644 (file)
--- a/gdb/i387-tdep.c
+++ b/gdb/i387-tdep.c
@@ -1,6 +1,6 @@
 /* Intel 387 floating point stuff.
 
-   Copyright (C) 1988-2018 Free Software Foundation, Inc.
+   Copyright (C) 1988-2020 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -28,7 +28,7 @@
 
 #include "i386-tdep.h"
 #include "i387-tdep.h"
-#include "x86-xstate.h"
+#include "gdbsupport/x86-xstate.h"
 
 /* Print the floating point number specified by RAW.  */
 
@@ -332,7 +332,7 @@ i387_convert_register_p (struct gdbarch *gdbarch, int regnum,
       /* Floating point registers must be converted unless we are
         accessing them in their hardware type or TYPE is not float.  */
       if (type == i387_ext_type (gdbarch)
-         || TYPE_CODE (type) != TYPE_CODE_FLT)
+         || type->code () != TYPE_CODE_FLT)
        return 0;
       else
        return 1;
@@ -355,7 +355,7 @@ i387_register_to_value (struct frame_info *frame, int regnum,
   gdb_assert (i386_fp_regnum_p (gdbarch, regnum));
 
   /* We only support floating-point values.  */
-  if (TYPE_CODE (type) != TYPE_CODE_FLT)
+  if (type->code () != TYPE_CODE_FLT)
     {
       warning (_("Cannot convert floating-point register value "
               "to non-floating-point type."));
@@ -387,7 +387,7 @@ i387_value_to_register (struct frame_info *frame, int regnum,
   gdb_assert (i386_fp_regnum_p (gdbarch, regnum));
 
   /* We only support floating-point values.  */
-  if (TYPE_CODE (type) != TYPE_CODE_FLT)
+  if (type->code () != TYPE_CODE_FLT)
     {
       warning (_("Cannot convert non-floating-point type "
               "to floating-point register value."));
@@ -450,7 +450,7 @@ i387_supply_fsave (struct regcache *regcache, int regnum, const void *fsave)
       {
        if (fsave == NULL)
          {
-           regcache_raw_supply (regcache, i, NULL);
+           regcache->raw_supply (i, NULL);
            continue;
          }
 
@@ -465,22 +465,22 @@ i387_supply_fsave (struct regcache *regcache, int regnum, const void *fsave)
            val[2] = val[3] = 0;
            if (i == I387_FOP_REGNUM (tdep))
              val[1] &= ((1 << 3) - 1);
-           regcache_raw_supply (regcache, i, val);
+           regcache->raw_supply (i, val);
          }
        else
-         regcache_raw_supply (regcache, i, FSAVE_ADDR (tdep, regs, i));
+         regcache->raw_supply (i, FSAVE_ADDR (tdep, regs, i));
       }
 
   /* Provide dummy values for the SSE registers.  */
   for (i = I387_XMM0_REGNUM (tdep); i < I387_MXCSR_REGNUM (tdep); i++)
     if (regnum == -1 || regnum == i)
-      regcache_raw_supply (regcache, i, NULL);
+      regcache->raw_supply (i, NULL);
   if (regnum == -1 || regnum == I387_MXCSR_REGNUM (tdep))
     {
       gdb_byte buf[4];
 
       store_unsigned_integer (buf, 4, byte_order, I387_MXCSR_INIT_VAL);
-      regcache_raw_supply (regcache, I387_MXCSR_REGNUM (tdep), buf);
+      regcache->raw_supply (I387_MXCSR_REGNUM (tdep), buf);
     }
 }
 
@@ -508,7 +508,7 @@ i387_collect_fsave (const struct regcache *regcache, int regnum, void *fsave)
          {
            gdb_byte buf[4];
 
-           regcache_raw_collect (regcache, i, buf);
+           regcache->raw_collect (i, buf);
 
            if (i == I387_FOP_REGNUM (tdep))
              {
@@ -520,7 +520,7 @@ i387_collect_fsave (const struct regcache *regcache, int regnum, void *fsave)
            memcpy (FSAVE_ADDR (tdep, regs, i), buf, 2);
          }
        else
-         regcache_raw_collect (regcache, i, FSAVE_ADDR (tdep, regs, i));
+         regcache->raw_collect (i, FSAVE_ADDR (tdep, regs, i));
       }
 }
 \f
@@ -597,7 +597,7 @@ i387_supply_fxsave (struct regcache *regcache, int regnum, const void *fxsave)
       {
        if (regs == NULL)
          {
-           regcache_raw_supply (regcache, i, NULL);
+           regcache->raw_supply (i, NULL);
            continue;
          }
 
@@ -644,18 +644,18 @@ i387_supply_fxsave (struct regcache *regcache, int regnum, const void *fxsave)
                val[0] = ftag & 0xff;
                val[1] = (ftag >> 8) & 0xff;
              }
-           regcache_raw_supply (regcache, i, val);
+           regcache->raw_supply (i, val);
          }
        else
-         regcache_raw_supply (regcache, i, FXSAVE_ADDR (tdep, regs, i));
+         regcache->raw_supply (i, FXSAVE_ADDR (tdep, regs, i));
       }
 
   if (regnum == I387_MXCSR_REGNUM (tdep) || regnum == -1)
     {
       if (regs == NULL)
-       regcache_raw_supply (regcache, I387_MXCSR_REGNUM (tdep), NULL);
+       regcache->raw_supply (I387_MXCSR_REGNUM (tdep), NULL);
       else
-       regcache_raw_supply (regcache, I387_MXCSR_REGNUM (tdep),
+       regcache->raw_supply (I387_MXCSR_REGNUM (tdep),
                             FXSAVE_MXCSR_ADDR (regs));
     }
 }
@@ -685,7 +685,7 @@ i387_collect_fxsave (const struct regcache *regcache, int regnum, void *fxsave)
          {
            gdb_byte buf[4];
 
-           regcache_raw_collect (regcache, i, buf);
+           regcache->raw_collect (i, buf);
 
            if (i == I387_FOP_REGNUM (tdep))
              {
@@ -716,11 +716,11 @@ i387_collect_fxsave (const struct regcache *regcache, int regnum, void *fxsave)
            memcpy (FXSAVE_ADDR (tdep, regs, i), buf, 2);
          }
        else
-         regcache_raw_collect (regcache, i, FXSAVE_ADDR (tdep, regs, i));
+         regcache->raw_collect (i, FXSAVE_ADDR (tdep, regs, i));
       }
 
   if (regnum == I387_MXCSR_REGNUM (tdep) || regnum == -1)
-    regcache_raw_collect (regcache, I387_MXCSR_REGNUM (tdep),
+    regcache->raw_collect (I387_MXCSR_REGNUM (tdep),
                          FXSAVE_MXCSR_ADDR (regs));
 }
 
@@ -924,6 +924,12 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
   const gdb_byte *regs = (const gdb_byte *) xsave;
   int i;
+  /* In 64-bit mode the split between "low" and "high" ZMM registers is at
+     ZMM16.  Outside of 64-bit mode there are no "high" ZMM registers at all.
+     Precalculate the number to be used for the split point, with the all
+     registers in the "low" portion outside of 64-bit mode.  */
+  unsigned int zmm_endlo_regnum = I387_ZMM0H_REGNUM (tdep)
+                                 + std::min (tdep->num_zmm_regs, 16);
   ULONGEST clear_bv;
   static const gdb_byte zero[I386_MAX_REGISTER_SIZE] = { 0 };
   enum
@@ -996,74 +1002,69 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
 
     case pkeys:
       if ((clear_bv & X86_XSTATE_PKRU))
-       regcache_raw_supply (regcache, regnum, zero);
+       regcache->raw_supply (regnum, zero);
       else
-       regcache_raw_supply (regcache, regnum,
-                            XSAVE_PKEYS_ADDR (tdep, regs, regnum));
+       regcache->raw_supply (regnum, XSAVE_PKEYS_ADDR (tdep, regs, regnum));
       return;
 
     case avx512_zmm_h:
-      if ((clear_bv & (X86_XSTATE_ZMM_H | X86_XSTATE_ZMM)))
-       regcache_raw_supply (regcache, regnum, zero);
+      if ((clear_bv & (regnum < zmm_endlo_regnum ? X86_XSTATE_ZMM_H
+                                                : X86_XSTATE_ZMM)))
+       regcache->raw_supply (regnum, zero);
       else
-       regcache_raw_supply (regcache, regnum,
-                            XSAVE_AVX512_ZMM_H_ADDR (tdep, regs, regnum));
+       regcache->raw_supply (regnum,
+                             XSAVE_AVX512_ZMM_H_ADDR (tdep, regs, regnum));
       return;
 
     case avx512_k:
       if ((clear_bv & X86_XSTATE_K))
-       regcache_raw_supply (regcache, regnum, zero);
+       regcache->raw_supply (regnum, zero);
       else
-       regcache_raw_supply (regcache, regnum,
-                            XSAVE_AVX512_K_ADDR (tdep, regs, regnum));
+       regcache->raw_supply (regnum, XSAVE_AVX512_K_ADDR (tdep, regs, regnum));
       return;
 
     case avx512_ymmh_avx512:
       if ((clear_bv & X86_XSTATE_ZMM))
-       regcache_raw_supply (regcache, regnum, zero);
+       regcache->raw_supply (regnum, zero);
       else
-       regcache_raw_supply (regcache, regnum,
-                            XSAVE_YMM_AVX512_ADDR (tdep, regs, regnum));
+       regcache->raw_supply (regnum,
+                             XSAVE_YMM_AVX512_ADDR (tdep, regs, regnum));
       return;
 
     case avx512_xmm_avx512:
       if ((clear_bv & X86_XSTATE_ZMM))
-       regcache_raw_supply (regcache, regnum, zero);
+       regcache->raw_supply (regnum, zero);
       else
-       regcache_raw_supply (regcache, regnum,
-                            XSAVE_XMM_AVX512_ADDR (tdep, regs, regnum));
+       regcache->raw_supply (regnum,
+                             XSAVE_XMM_AVX512_ADDR (tdep, regs, regnum));
       return;
 
     case avxh:
       if ((clear_bv & X86_XSTATE_AVX))
-       regcache_raw_supply (regcache, regnum, zero);
+       regcache->raw_supply (regnum, zero);
       else
-       regcache_raw_supply (regcache, regnum,
-                            XSAVE_AVXH_ADDR (tdep, regs, regnum));
+       regcache->raw_supply (regnum, XSAVE_AVXH_ADDR (tdep, regs, regnum));
       return;
 
     case mpx:
       if ((clear_bv & X86_XSTATE_BNDREGS))
-       regcache_raw_supply (regcache, regnum, zero);
+       regcache->raw_supply (regnum, zero);
       else
-       regcache_raw_supply (regcache, regnum,
-                            XSAVE_MPX_ADDR (tdep, regs, regnum));
+       regcache->raw_supply (regnum, XSAVE_MPX_ADDR (tdep, regs, regnum));
       return;
 
     case sse:
       if ((clear_bv & X86_XSTATE_SSE))
-       regcache_raw_supply (regcache, regnum, zero);
+       regcache->raw_supply (regnum, zero);
       else
-       regcache_raw_supply (regcache, regnum,
-                            FXSAVE_ADDR (tdep, regs, regnum));
+       regcache->raw_supply (regnum, FXSAVE_ADDR (tdep, regs, regnum));
       return;
 
     case x87:
       if ((clear_bv & X86_XSTATE_X87))
-       regcache_raw_supply (regcache, regnum, zero);
+       regcache->raw_supply (regnum, zero);
       else
-       regcache_raw_supply (regcache, regnum,
-                            FXSAVE_ADDR (tdep, regs, regnum));
+       regcache->raw_supply (regnum, FXSAVE_ADDR (tdep, regs, regnum));
       return;
 
     case all:
@@ -1075,35 +1076,30 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
              for (i = I387_PKRU_REGNUM (tdep);
                   i < I387_PKEYSEND_REGNUM (tdep);
                   i++)
-               regcache_raw_supply (regcache, i, zero);
+               regcache->raw_supply (i, zero);
            }
          else
            {
              for (i = I387_PKRU_REGNUM (tdep);
                   i < I387_PKEYSEND_REGNUM (tdep);
                   i++)
-               regcache_raw_supply (regcache, i,
-                                    XSAVE_PKEYS_ADDR (tdep, regs, i));
+               regcache->raw_supply (i, XSAVE_PKEYS_ADDR (tdep, regs, i));
            }
        }
 
-      /* Handle the upper ZMM registers.  */
-      if ((tdep->xcr0 & (X86_XSTATE_ZMM_H | X86_XSTATE_ZMM)))
+      /* Handle the upper halves of the low 8/16 ZMM registers.  */
+      if ((tdep->xcr0 & X86_XSTATE_ZMM_H))
        {
-         if ((clear_bv & (X86_XSTATE_ZMM_H | X86_XSTATE_ZMM)))
+         if ((clear_bv & X86_XSTATE_ZMM_H))
            {
-             for (i = I387_ZMM0H_REGNUM (tdep);
-                  i < I387_ZMMENDH_REGNUM (tdep);
-                  i++)
-               regcache_raw_supply (regcache, i, zero);
+             for (i = I387_ZMM0H_REGNUM (tdep); i < zmm_endlo_regnum; i++)
+               regcache->raw_supply (i, zero);
            }
          else
            {
-             for (i = I387_ZMM0H_REGNUM (tdep);
-                  i < I387_ZMMENDH_REGNUM (tdep);
-                  i++)
-               regcache_raw_supply (regcache, i,
-                                    XSAVE_AVX512_ZMM_H_ADDR (tdep, regs, i));
+             for (i = I387_ZMM0H_REGNUM (tdep); i < zmm_endlo_regnum; i++)
+               regcache->raw_supply (i,
+                                     XSAVE_AVX512_ZMM_H_ADDR (tdep, regs, i));
            }
        }
 
@@ -1115,44 +1111,46 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
              for (i = I387_K0_REGNUM (tdep);
                   i < I387_KEND_REGNUM (tdep);
                   i++)
-               regcache_raw_supply (regcache, i, zero);
+               regcache->raw_supply (i, zero);
            }
          else
            {
              for (i = I387_K0_REGNUM (tdep);
                   i < I387_KEND_REGNUM (tdep);
                   i++)
-               regcache_raw_supply (regcache, i,
-                                    XSAVE_AVX512_K_ADDR (tdep, regs, i));
+               regcache->raw_supply (i, XSAVE_AVX512_K_ADDR (tdep, regs, i));
            }
        }
 
-      /* Handle the YMM_AVX512 registers.  */
+      /* Handle the upper 16 ZMM/YMM/XMM registers (if any).  */
       if ((tdep->xcr0 & X86_XSTATE_ZMM))
        {
          if ((clear_bv & X86_XSTATE_ZMM))
            {
+             for (i = zmm_endlo_regnum; i < I387_ZMMENDH_REGNUM (tdep); i++)
+               regcache->raw_supply (i, zero);
              for (i = I387_YMM16H_REGNUM (tdep);
                   i < I387_YMMH_AVX512_END_REGNUM (tdep);
                   i++)
-               regcache_raw_supply (regcache, i, zero);
+               regcache->raw_supply (i, zero);
              for (i = I387_XMM16_REGNUM (tdep);
                   i < I387_XMM_AVX512_END_REGNUM (tdep);
                   i++)
-               regcache_raw_supply (regcache, i, zero);
+               regcache->raw_supply (i, zero);
            }
          else
            {
+             for (i = zmm_endlo_regnum; i < I387_ZMMENDH_REGNUM (tdep); i++)
+               regcache->raw_supply (i,
+                                     XSAVE_AVX512_ZMM_H_ADDR (tdep, regs, i));
              for (i = I387_YMM16H_REGNUM (tdep);
                   i < I387_YMMH_AVX512_END_REGNUM (tdep);
                   i++)
-               regcache_raw_supply (regcache, i,
-                                    XSAVE_YMM_AVX512_ADDR (tdep, regs, i));
+               regcache->raw_supply (i, XSAVE_YMM_AVX512_ADDR (tdep, regs, i));
              for (i = I387_XMM16_REGNUM (tdep);
                   i < I387_XMM_AVX512_END_REGNUM (tdep);
                   i++)
-               regcache_raw_supply (regcache, i,
-                                    XSAVE_XMM_AVX512_ADDR (tdep, regs, i));
+               regcache->raw_supply (i, XSAVE_XMM_AVX512_ADDR (tdep, regs, i));
            }
        }
       /* Handle the upper YMM registers.  */
@@ -1163,15 +1161,14 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
              for (i = I387_YMM0H_REGNUM (tdep);
                   i < I387_YMMENDH_REGNUM (tdep);
                   i++)
-               regcache_raw_supply (regcache, i, zero);
+               regcache->raw_supply (i, zero);
            }
          else
            {
              for (i = I387_YMM0H_REGNUM (tdep);
                   i < I387_YMMENDH_REGNUM (tdep);
                   i++)
-               regcache_raw_supply (regcache, i,
-                                    XSAVE_AVXH_ADDR (tdep, regs, i));
+               regcache->raw_supply (i, XSAVE_AVXH_ADDR (tdep, regs, i));
            }
        }
 
@@ -1182,14 +1179,13 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
            {
              for (i = I387_BND0R_REGNUM (tdep);
                   i < I387_BNDCFGU_REGNUM (tdep); i++)
-               regcache_raw_supply (regcache, i, zero);
+               regcache->raw_supply (i, zero);
            }
          else
            {
              for (i = I387_BND0R_REGNUM (tdep);
                   i < I387_BNDCFGU_REGNUM (tdep); i++)
-               regcache_raw_supply (regcache, i,
-                                    XSAVE_MPX_ADDR (tdep, regs, i));
+               regcache->raw_supply (i, XSAVE_MPX_ADDR (tdep, regs, i));
            }
        }
 
@@ -1200,14 +1196,13 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
            {
              for (i = I387_BNDCFGU_REGNUM (tdep);
                   i < I387_MPXEND_REGNUM (tdep); i++)
-               regcache_raw_supply (regcache, i, zero);
+               regcache->raw_supply (i, zero);
            }
          else
            {
              for (i = I387_BNDCFGU_REGNUM (tdep);
                   i < I387_MPXEND_REGNUM (tdep); i++)
-               regcache_raw_supply (regcache, i,
-                                    XSAVE_MPX_ADDR (tdep, regs, i));
+               regcache->raw_supply (i, XSAVE_MPX_ADDR (tdep, regs, i));
            }
        }
 
@@ -1219,14 +1214,13 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
              for (i = I387_XMM0_REGNUM (tdep);
                   i < I387_MXCSR_REGNUM (tdep);
                   i++)
-               regcache_raw_supply (regcache, i, zero);
+               regcache->raw_supply (i, zero);
            }
          else
            {
              for (i = I387_XMM0_REGNUM (tdep);
                   i < I387_MXCSR_REGNUM (tdep); i++)
-               regcache_raw_supply (regcache, i,
-                                    FXSAVE_ADDR (tdep, regs, i));
+               regcache->raw_supply (i, FXSAVE_ADDR (tdep, regs, i));
            }
        }
 
@@ -1238,14 +1232,14 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
              for (i = I387_ST0_REGNUM (tdep);
                   i < I387_FCTRL_REGNUM (tdep);
                   i++)
-               regcache_raw_supply (regcache, i, zero);
+               regcache->raw_supply (i, zero);
            }
          else
            {
              for (i = I387_ST0_REGNUM (tdep);
                   i < I387_FCTRL_REGNUM (tdep);
                   i++)
-               regcache_raw_supply (regcache, i, FXSAVE_ADDR (tdep, regs, i));
+               regcache->raw_supply (i, FXSAVE_ADDR (tdep, regs, i));
            }
        }
       break;
@@ -1263,17 +1257,17 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
 
                store_unsigned_integer (buf, 4, byte_order,
                                        I387_FCTRL_INIT_VAL);
-               regcache_raw_supply (regcache, i, buf);
+               regcache->raw_supply (i, buf);
              }
            else if (i == I387_FTAG_REGNUM (tdep))
              {
                gdb_byte buf[4];
 
                store_unsigned_integer (buf, 4, byte_order, 0xffff);
-               regcache_raw_supply (regcache, i, buf);
+               regcache->raw_supply (i, buf);
              }
            else
-             regcache_raw_supply (regcache, i, zero);
+             regcache->raw_supply (i, zero);
          }
        /* Most of the FPU control registers occupy only 16 bits in
           the xsave extended state.  Give those a special treatment.  */
@@ -1318,10 +1312,10 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
                val[0] = ftag & 0xff;
                val[1] = (ftag >> 8) & 0xff;
              }
-           regcache_raw_supply (regcache, i, val);
+           regcache->raw_supply (i, val);
          }
        else
-         regcache_raw_supply (regcache, i, FXSAVE_ADDR (tdep, regs, i));
+         regcache->raw_supply (i, FXSAVE_ADDR (tdep, regs, i));
       }
 
   if (regnum == I387_MXCSR_REGNUM (tdep) || regnum == -1)
@@ -1334,11 +1328,11 @@ i387_supply_xsave (struct regcache *regcache, int regnum,
          gdb_byte buf[4];
 
          store_unsigned_integer (buf, 4, byte_order, I387_MXCSR_INIT_VAL);
-         regcache_raw_supply (regcache, I387_MXCSR_REGNUM (tdep), buf);
+         regcache->raw_supply (I387_MXCSR_REGNUM (tdep), buf);
        }
       else
-       regcache_raw_supply (regcache, I387_MXCSR_REGNUM (tdep),
-                            FXSAVE_MXCSR_ADDR (regs));
+       regcache->raw_supply (I387_MXCSR_REGNUM (tdep),
+                             FXSAVE_MXCSR_ADDR (regs));
     }
 }
 
@@ -1354,7 +1348,10 @@ i387_collect_xsave (const struct regcache *regcache, int regnum,
   gdb_byte *p, *regs = (gdb_byte *) xsave;
   gdb_byte raw[I386_MAX_REGISTER_SIZE];
   ULONGEST initial_xstate_bv, clear_bv, xstate_bv = 0;
-  int i;
+  unsigned int i;
+  /* See the comment in i387_supply_xsave().  */
+  unsigned int zmm_endlo_regnum = I387_ZMM0H_REGNUM (tdep)
+                                 + std::min (tdep->num_zmm_regs, 16);
   enum
     {
       x87_ctrl_or_mxcsr = 0x1,
@@ -1455,9 +1452,8 @@ i387_collect_xsave (const struct regcache *regcache, int regnum,
             i < I387_MPXEND_REGNUM (tdep); i++)
          memset (XSAVE_MPX_ADDR (tdep, regs, i), 0, 8);
 
-      if ((clear_bv & (X86_XSTATE_ZMM_H | X86_XSTATE_ZMM)))
-       for (i = I387_ZMM0H_REGNUM (tdep);
-            i < I387_ZMMENDH_REGNUM (tdep); i++)
+      if ((clear_bv & X86_XSTATE_ZMM_H))
+       for (i = I387_ZMM0H_REGNUM (tdep); i < zmm_endlo_regnum; i++)
          memset (XSAVE_AVX512_ZMM_H_ADDR (tdep, regs, i), 0, 32);
 
       if ((clear_bv & X86_XSTATE_K))
@@ -1467,6 +1463,8 @@ i387_collect_xsave (const struct regcache *regcache, int regnum,
 
       if ((clear_bv & X86_XSTATE_ZMM))
        {
+         for (i = zmm_endlo_regnum; i < I387_ZMMENDH_REGNUM (tdep); i++)
+           memset (XSAVE_AVX512_ZMM_H_ADDR (tdep, regs, i), 0, 32);
          for (i = I387_YMM16H_REGNUM (tdep);
               i < I387_YMMH_AVX512_END_REGNUM (tdep); i++)
            memset (XSAVE_YMM_AVX512_ADDR (tdep, regs, i), 0, 16);
@@ -1490,7 +1488,7 @@ i387_collect_xsave (const struct regcache *regcache, int regnum,
         require clearing.  */
       if ((clear_bv & (X86_XSTATE_AVX | X86_XSTATE_SSE))
          == (X86_XSTATE_AVX | X86_XSTATE_SSE))
-       store_unsigned_integer (FXSAVE_ADDR (tdep, regs, i), 2, byte_order,
+       store_unsigned_integer (FXSAVE_MXCSR_ADDR (regs), 2, byte_order,
                                I387_MXCSR_INIT_VAL);
 
       if ((clear_bv & X86_XSTATE_X87))
@@ -1519,7 +1517,7 @@ i387_collect_xsave (const struct regcache *regcache, int regnum,
        for (i = I387_PKRU_REGNUM (tdep);
             i < I387_PKEYSEND_REGNUM (tdep); i++)
          {
-           regcache_raw_collect (regcache, i, raw);
+           regcache->raw_collect (i, raw);
            p = XSAVE_PKEYS_ADDR (tdep, regs, i);
            if (memcmp (raw, p, 4) != 0)
              {
@@ -1533,7 +1531,7 @@ i387_collect_xsave (const struct regcache *regcache, int regnum,
        for (i = I387_ZMM0H_REGNUM (tdep);
             i < I387_ZMMENDH_REGNUM (tdep); i++)
          {
-           regcache_raw_collect (regcache, i, raw);
+           regcache->raw_collect (i, raw);
            p = XSAVE_AVX512_ZMM_H_ADDR (tdep, regs, i);
            if (memcmp (raw, p, 32) != 0)
              {
@@ -1547,7 +1545,7 @@ i387_collect_xsave (const struct regcache *regcache, int regnum,
        for (i = I387_K0_REGNUM (tdep);
             i < I387_KEND_REGNUM (tdep); i++)
          {
-           regcache_raw_collect (regcache, i, raw);
+           regcache->raw_collect (i, raw);
            p = XSAVE_AVX512_K_ADDR (tdep, regs, i);
            if (memcmp (raw, p, 8) != 0)
              {
@@ -1562,7 +1560,7 @@ i387_collect_xsave (const struct regcache *regcache, int regnum,
          for (i = I387_YMM16H_REGNUM (tdep);
               i < I387_YMMH_AVX512_END_REGNUM (tdep); i++)
            {
-             regcache_raw_collect (regcache, i, raw);
+             regcache->raw_collect (i, raw);
              p = XSAVE_YMM_AVX512_ADDR (tdep, regs, i);
              if (memcmp (raw, p, 16) != 0)
                {
@@ -1573,7 +1571,7 @@ i387_collect_xsave (const struct regcache *regcache, int regnum,
          for (i = I387_XMM16_REGNUM (tdep);
               i < I387_XMM_AVX512_END_REGNUM (tdep); i++)
            {
-             regcache_raw_collect (regcache, i, raw);
+             regcache->raw_collect (i, raw);
              p = XSAVE_XMM_AVX512_ADDR (tdep, regs, i);
              if (memcmp (raw, p, 16) != 0)
                {
@@ -1588,7 +1586,7 @@ i387_collect_xsave (const struct regcache *regcache, int regnum,
        for (i = I387_BND0R_REGNUM (tdep);
             i < I387_BNDCFGU_REGNUM (tdep); i++)
          {
-           regcache_raw_collect (regcache, i, raw);
+           regcache->raw_collect (i, raw);
            p = XSAVE_MPX_ADDR (tdep, regs, i);
            if (memcmp (raw, p, 16))
              {
@@ -1602,7 +1600,7 @@ i387_collect_xsave (const struct regcache *regcache, int regnum,
        for (i = I387_BNDCFGU_REGNUM (tdep);
             i < I387_MPXEND_REGNUM (tdep); i++)
          {
-           regcache_raw_collect (regcache, i, raw);
+           regcache->raw_collect (i, raw);
            p = XSAVE_MPX_ADDR (tdep, regs, i);
            if (memcmp (raw, p, 8))
              {
@@ -1616,7 +1614,7 @@ i387_collect_xsave (const struct regcache *regcache, int regnum,
        for (i = I387_YMM0H_REGNUM (tdep);
             i < I387_YMMENDH_REGNUM (tdep); i++)
          {
-           regcache_raw_collect (regcache, i, raw);
+           regcache->raw_collect (i, raw);
            p = XSAVE_AVXH_ADDR (tdep, regs, i);
            if (memcmp (raw, p, 16))
              {
@@ -1630,7 +1628,7 @@ i387_collect_xsave (const struct regcache *regcache, int regnum,
        for (i = I387_XMM0_REGNUM (tdep);
             i < I387_MXCSR_REGNUM (tdep); i++)
          {
-           regcache_raw_collect (regcache, i, raw);
+           regcache->raw_collect (i, raw);
            p = FXSAVE_ADDR (tdep, regs, i);
            if (memcmp (raw, p, 16))
              {
@@ -1642,8 +1640,8 @@ i387_collect_xsave (const struct regcache *regcache, int regnum,
       if ((tdep->xcr0 & X86_XSTATE_AVX) || (tdep->xcr0 & X86_XSTATE_SSE))
        {
          i = I387_MXCSR_REGNUM (tdep);
-         regcache_raw_collect (regcache, i, raw);
-         p = FXSAVE_ADDR (tdep, regs, i);
+         regcache->raw_collect (i, raw);
+         p = FXSAVE_MXCSR_ADDR (regs);
          if (memcmp (raw, p, 4))
            {
              /* Now, we need to mark one of either SSE of AVX as enabled.
@@ -1663,7 +1661,7 @@ i387_collect_xsave (const struct regcache *regcache, int regnum,
        for (i = I387_ST0_REGNUM (tdep);
             i < I387_FCTRL_REGNUM (tdep); i++)
          {
-           regcache_raw_collect (regcache, i, raw);
+           regcache->raw_collect (i, raw);
            p = FXSAVE_ADDR (tdep, regs, i);
            if (memcmp (raw, p, 10))
              {
@@ -1675,7 +1673,7 @@ i387_collect_xsave (const struct regcache *regcache, int regnum,
   else
     {
       /* Check if REGNUM is changed.  */
-      regcache_raw_collect (regcache, regnum, raw);
+      regcache->raw_collect (regnum, raw);
 
       switch (regclass)
        {
@@ -1745,7 +1743,7 @@ i387_collect_xsave (const struct regcache *regcache, int regnum,
        case mpx:
          if (regnum < I387_BNDCFGU_REGNUM (tdep))
            {
-             regcache_raw_collect (regcache, regnum, raw);
+             regcache->raw_collect (regnum, raw);
              p = XSAVE_MPX_ADDR (tdep, regs, regnum);
              if (memcmp (raw, p, 16))
                {
@@ -1815,7 +1813,7 @@ i387_collect_xsave (const struct regcache *regcache, int regnum,
          {
            gdb_byte buf[4];
 
-           regcache_raw_collect (regcache, i, buf);
+           regcache->raw_collect (i, buf);
 
            if (i == I387_FOP_REGNUM (tdep))
              {
@@ -1854,7 +1852,7 @@ i387_collect_xsave (const struct regcache *regcache, int regnum,
          {
            int regsize;
 
-           regcache_raw_collect (regcache, i, raw);
+           regcache->raw_collect (i, raw);
            regsize = regcache_register_size (regcache, i);
            p = FXSAVE_ADDR (tdep, regs, i);
            if (memcmp (raw, p, regsize))
@@ -1962,6 +1960,6 @@ i387_reset_bnd_regs (struct gdbarch *gdbarch, struct regcache *regcache)
 
       memset (bnd_buf, 0, 16);
       for (int i = 0; i < I387_NUM_BND_REGS; i++)
-       regcache_raw_write (regcache, I387_BND0R_REGNUM (tdep) + i, bnd_buf);
+       regcache->raw_write (I387_BND0R_REGNUM (tdep) + i, bnd_buf);
     }
 }