Run clang-format.shusers/simark/clang-format

Change-Id: Ia948cc26d534b0dd02702244d52434b1a2093968

1 files changed, 324 insertions, 323 deletions

diff --git a/gdbserver/i387-fp.cc b/gdbserver/i387-fp.cc
index 12cb614..c578f324 100644
--- a/gdbserver/i387-fp.cc
+++ b/gdbserver/i387-fp.cc
@@ -31,7 +31,8 @@ static const int num_pkeys_registers = 1;
 /* These structs should have the proper sizes and alignment on both
    i386 and x86-64 machines.  */
 
-struct i387_fsave {
+struct i387_fsave
+{
   /* All these are only sixteen bits, plus padding, except for fop (which
      is only eleven bits), and fooff / fioff (which are 32 bits each).  */
   unsigned short fctrl;
@@ -51,7 +52,8 @@ struct i387_fsave {
   unsigned char st_space[80];
 };
 
-struct i387_fxsave {
+struct i387_fxsave
+{
   /* All these are only sixteen bits, plus padding, except for fop (which
      is only eleven bits), and fooff / fioff (which are 32 bits each).  */
   unsigned short fctrl;
@@ -75,7 +77,8 @@ struct i387_fxsave {
   unsigned char xmm_space[256];
 };
 
-struct i387_xsave {
+struct i387_xsave
+{
   /* All these are only sixteen bits, plus padding, except for fop (which
      is only eleven bits), and fooff / fioff (which are 32 bits each).  */
   unsigned short fctrl;
@@ -149,7 +152,7 @@ i387_cache_to_fsave (struct regcache *regcache, void *buf)
 
   for (i = 0; i < 8; i++)
     collect_register (regcache, i + st0_regnum,
-		      ((char *) &fp->st_space[0]) + i * 10);
+                      ((char *) &fp->st_space[0]) + i * 10);
 
   fp->fioff = regcache_raw_get_unsigned_by_name (regcache, "fioff");
   fp->fooff = regcache_raw_get_unsigned_by_name (regcache, "fooff");
@@ -176,7 +179,7 @@ i387_fsave_to_cache (struct regcache *regcache, const void *buf)
 
   for (i = 0; i < 8; i++)
     supply_register (regcache, i + st0_regnum,
-		     ((char *) &fp->st_space[0]) + i * 10);
+                     ((char *) &fp->st_space[0]) + i * 10);
 
   supply_register_by_name (regcache, "fioff", &fp->fioff);
   supply_register_by_name (regcache, "fooff", &fp->fooff);
@@ -215,10 +218,10 @@ i387_cache_to_fxsave (struct regcache *regcache, void *buf)
 
   for (i = 0; i < 8; i++)
     collect_register (regcache, i + st0_regnum,
-		      ((char *) &fp->st_space[0]) + i * 16);
+                      ((char *) &fp->st_space[0]) + i * 16);
   for (i = 0; i < num_xmm_registers; i++)
     collect_register (regcache, i + xmm0_regnum,
-		      ((char *) &fp->xmm_space[0]) + i * 16);
+                      ((char *) &fp->xmm_space[0]) + i * 16);
 
   fp->fioff = regcache_raw_get_unsigned_by_name (regcache, "fioff");
   fp->fooff = regcache_raw_get_unsigned_by_name (regcache, "fooff");
@@ -240,7 +243,7 @@ i387_cache_to_fxsave (struct regcache *regcache, void *buf)
       int tag = (val >> (i * 2)) & 3;
 
       if (tag != 3)
-	val2 |= (1 << i);
+        val2 |= (1 << i);
     }
   fp->ftag = val2;
 
@@ -278,60 +281,60 @@ i387_cache_to_xsave (struct regcache *regcache, void *buf)
   if (clear_bv)
     {
       if ((clear_bv & X86_XSTATE_X87))
-	{
-	  for (i = 0; i < 8; i++)
-	    memset (((char *) &fp->st_space[0]) + i * 16, 0, 10);
-
-	  fp->fioff = 0;
-	  fp->fooff = 0;
-	  fp->fctrl = I387_FCTRL_INIT_VAL;
-	  fp->fstat = 0;
-	  fp->ftag = 0;
-	  fp->fiseg = 0;
-	  fp->foseg = 0;
-	  fp->fop = 0;
-	}
+        {
+          for (i = 0; i < 8; i++)
+            memset (((char *) &fp->st_space[0]) + i * 16, 0, 10);
+
+          fp->fioff = 0;
+          fp->fooff = 0;
+          fp->fctrl = I387_FCTRL_INIT_VAL;
+          fp->fstat = 0;
+          fp->ftag = 0;
+          fp->fiseg = 0;
+          fp->foseg = 0;
+          fp->fop = 0;
+        }
 
       if ((clear_bv & X86_XSTATE_SSE))
-	for (i = 0; i < num_xmm_registers; i++)
-	  memset (((char *) &fp->xmm_space[0]) + i * 16, 0, 16);
+        for (i = 0; i < num_xmm_registers; i++)
+          memset (((char *) &fp->xmm_space[0]) + i * 16, 0, 16);
 
       if ((clear_bv & X86_XSTATE_AVX))
-	for (i = 0; i < num_xmm_registers; i++)
-	  memset (((char *) &fp->ymmh_space[0]) + i * 16, 0, 16);
+        for (i = 0; i < num_xmm_registers; i++)
+          memset (((char *) &fp->ymmh_space[0]) + i * 16, 0, 16);
 
       if ((clear_bv & X86_XSTATE_SSE) && (clear_bv & X86_XSTATE_AVX))
-	memset (((char *) &fp->mxcsr), 0, 4);
+        memset (((char *) &fp->mxcsr), 0, 4);
 
       if ((clear_bv & X86_XSTATE_BNDREGS))
-	for (i = 0; i < num_mpx_bnd_registers; i++)
-	  memset (((char *) &fp->mpx_bnd_space[0]) + i * 16, 0, 16);
+        for (i = 0; i < num_mpx_bnd_registers; i++)
+          memset (((char *) &fp->mpx_bnd_space[0]) + i * 16, 0, 16);
 
       if ((clear_bv & X86_XSTATE_BNDCFG))
-	for (i = 0; i < num_mpx_cfg_registers; i++)
-	  memset (((char *) &fp->mpx_cfg_space[0]) + i * 8, 0, 8);
+        for (i = 0; i < num_mpx_cfg_registers; i++)
+          memset (((char *) &fp->mpx_cfg_space[0]) + i * 8, 0, 8);
 
       if ((clear_bv & X86_XSTATE_K))
-	for (i = 0; i < num_avx512_k_registers; i++)
-	  memset (((char *) &fp->k_space[0]) + i * 8, 0, 8);
+        for (i = 0; i < num_avx512_k_registers; i++)
+          memset (((char *) &fp->k_space[0]) + i * 8, 0, 8);
 
       if ((clear_bv & X86_XSTATE_ZMM_H))
-	for (i = 0; i < num_avx512_zmmh_low_registers; i++)
-	  memset (((char *) &fp->zmmh_low_space[0]) + i * 32, 0, 32);
+        for (i = 0; i < num_avx512_zmmh_low_registers; i++)
+          memset (((char *) &fp->zmmh_low_space[0]) + i * 32, 0, 32);
 
       if ((clear_bv & X86_XSTATE_ZMM))
-	{
-	  for (i = 0; i < num_avx512_zmmh_high_registers; i++)
-	    memset (((char *) &fp->zmmh_low_space[0]) + 32 + i * 64, 0, 32);
-	  for (i = 0; i < num_avx512_xmm_registers; i++)
-	    memset (((char *) &fp->zmmh_high_space[0]) + i * 64, 0, 16);
-	  for (i = 0; i < num_avx512_ymmh_registers; i++)
-	    memset (((char *) &fp->zmmh_high_space[0]) + 16 + i * 64, 0, 16);
-	}
+        {
+          for (i = 0; i < num_avx512_zmmh_high_registers; i++)
+            memset (((char *) &fp->zmmh_low_space[0]) + 32 + i * 64, 0, 32);
+          for (i = 0; i < num_avx512_xmm_registers; i++)
+            memset (((char *) &fp->zmmh_high_space[0]) + i * 64, 0, 16);
+          for (i = 0; i < num_avx512_ymmh_registers; i++)
+            memset (((char *) &fp->zmmh_high_space[0]) + 16 + i * 64, 0, 16);
+        }
 
       if ((clear_bv & X86_XSTATE_PKRU))
-	for (i = 0; i < num_pkeys_registers; i++)
-	  memset (((char *) &fp->pkru_space[0]) + i * 4, 0, 4);
+        for (i = 0; i < num_pkeys_registers; i++)
+          memset (((char *) &fp->pkru_space[0]) + i * 4, 0, 4);
     }
 
   /* Check if any x87 registers are changed.  */
@@ -340,15 +343,15 @@ i387_cache_to_xsave (struct regcache *regcache, void *buf)
       int st0_regnum = find_regno (regcache->tdesc, "st0");
 
       for (i = 0; i < 8; i++)
-	{
-	  collect_register (regcache, i + st0_regnum, raw);
-	  p = ((char *) &fp->st_space[0]) + i * 16;
-	  if (memcmp (raw, p, 10))
-	    {
-	      xstate_bv |= X86_XSTATE_X87;
-	      memcpy (p, raw, 10);
-	    }
-	}
+        {
+          collect_register (regcache, i + st0_regnum, raw);
+          p = ((char *) &fp->st_space[0]) + i * 16;
+          if (memcmp (raw, p, 10))
+            {
+              xstate_bv |= X86_XSTATE_X87;
+              memcpy (p, raw, 10);
+            }
+        }
     }
 
   /* Check if any SSE registers are changed.  */
@@ -356,16 +359,16 @@ i387_cache_to_xsave (struct regcache *regcache, void *buf)
     {
       int xmm0_regnum = find_regno (regcache->tdesc, "xmm0");
 
-      for (i = 0; i < num_xmm_registers; i++) 
-	{
-	  collect_register (regcache, i + xmm0_regnum, raw);
-	  p = ((char *) &fp->xmm_space[0]) + i * 16;
-	  if (memcmp (raw, p, 16))
-	    {
-	      xstate_bv |= X86_XSTATE_SSE;
-	      memcpy (p, raw, 16);
-	    }
-	}
+      for (i = 0; i < num_xmm_registers; i++)
+        {
+          collect_register (regcache, i + xmm0_regnum, raw);
+          p = ((char *) &fp->xmm_space[0]) + i * 16;
+          if (memcmp (raw, p, 16))
+            {
+              xstate_bv |= X86_XSTATE_SSE;
+              memcpy (p, raw, 16);
+            }
+        }
     }
 
   /* Check if any AVX registers are changed.  */
@@ -373,33 +376,33 @@ i387_cache_to_xsave (struct regcache *regcache, void *buf)
     {
       int ymm0h_regnum = find_regno (regcache->tdesc, "ymm0h");
 
-      for (i = 0; i < num_xmm_registers; i++) 
-	{
-	  collect_register (regcache, i + ymm0h_regnum, raw);
-	  p = ((char *) &fp->ymmh_space[0]) + i * 16;
-	  if (memcmp (raw, p, 16))
-	    {
-	      xstate_bv |= X86_XSTATE_AVX;
-	      memcpy (p, raw, 16);
-	    }
-	}
+      for (i = 0; i < num_xmm_registers; i++)
+        {
+          collect_register (regcache, i + ymm0h_regnum, raw);
+          p = ((char *) &fp->ymmh_space[0]) + i * 16;
+          if (memcmp (raw, p, 16))
+            {
+              xstate_bv |= X86_XSTATE_AVX;
+              memcpy (p, raw, 16);
+            }
+        }
     }
 
   /* Check if any bound register has changed.  */
   if ((x86_xcr0 & X86_XSTATE_BNDREGS))
     {
-     int bnd0r_regnum = find_regno (regcache->tdesc, "bnd0raw");
+      int bnd0r_regnum = find_regno (regcache->tdesc, "bnd0raw");
 
       for (i = 0; i < num_mpx_bnd_registers; i++)
-	{
-	  collect_register (regcache, i + bnd0r_regnum, raw);
-	  p = ((char *) &fp->mpx_bnd_space[0]) + i * 16;
-	  if (memcmp (raw, p, 16))
-	    {
-	      xstate_bv |= X86_XSTATE_BNDREGS;
-	      memcpy (p, raw, 16);
-	    }
-	}
+        {
+          collect_register (regcache, i + bnd0r_regnum, raw);
+          p = ((char *) &fp->mpx_bnd_space[0]) + i * 16;
+          if (memcmp (raw, p, 16))
+            {
+              xstate_bv |= X86_XSTATE_BNDREGS;
+              memcpy (p, raw, 16);
+            }
+        }
     }
 
   /* Check if any status register has changed.  */
@@ -408,15 +411,15 @@ i387_cache_to_xsave (struct regcache *regcache, void *buf)
       int bndcfg_regnum = find_regno (regcache->tdesc, "bndcfgu");
 
       for (i = 0; i < num_mpx_cfg_registers; i++)
-	{
-	  collect_register (regcache, i + bndcfg_regnum, raw);
-	  p = ((char *) &fp->mpx_cfg_space[0]) + i * 8;
-	  if (memcmp (raw, p, 8))
-	    {
-	      xstate_bv |= X86_XSTATE_BNDCFG;
-	      memcpy (p, raw, 8);
-	    }
-	}
+        {
+          collect_register (regcache, i + bndcfg_regnum, raw);
+          p = ((char *) &fp->mpx_cfg_space[0]) + i * 8;
+          if (memcmp (raw, p, 8))
+            {
+              xstate_bv |= X86_XSTATE_BNDCFG;
+              memcpy (p, raw, 8);
+            }
+        }
     }
 
   /* Check if any K registers are changed.  */
@@ -425,15 +428,15 @@ i387_cache_to_xsave (struct regcache *regcache, void *buf)
       int k0_regnum = find_regno (regcache->tdesc, "k0");
 
       for (i = 0; i < num_avx512_k_registers; i++)
-	{
-	  collect_register (regcache, i + k0_regnum, raw);
-	  p = ((char *) &fp->k_space[0]) + i * 8;
-	  if (memcmp (raw, p, 8) != 0)
-	    {
-	      xstate_bv |= X86_XSTATE_K;
-	      memcpy (p, raw, 8);
-	    }
-	}
+        {
+          collect_register (regcache, i + k0_regnum, raw);
+          p = ((char *) &fp->k_space[0]) + i * 8;
+          if (memcmp (raw, p, 8) != 0)
+            {
+              xstate_bv |= X86_XSTATE_K;
+              memcpy (p, raw, 8);
+            }
+        }
     }
 
   /* Check if any of ZMM0H-ZMM15H registers are changed.  */
@@ -442,72 +445,72 @@ i387_cache_to_xsave (struct regcache *regcache, void *buf)
       int zmm0h_regnum = find_regno (regcache->tdesc, "zmm0h");
 
       for (i = 0; i < num_avx512_zmmh_low_registers; i++)
-	{
-	  collect_register (regcache, i + zmm0h_regnum, raw);
-	  p = ((char *) &fp->zmmh_low_space[0]) + i * 32;
-	  if (memcmp (raw, p, 32) != 0)
-	    {
-	      xstate_bv |= X86_XSTATE_ZMM_H;
-	      memcpy (p, raw, 32);
-	    }
-	}
+        {
+          collect_register (regcache, i + zmm0h_regnum, raw);
+          p = ((char *) &fp->zmmh_low_space[0]) + i * 32;
+          if (memcmp (raw, p, 32) != 0)
+            {
+              xstate_bv |= X86_XSTATE_ZMM_H;
+              memcpy (p, raw, 32);
+            }
+        }
     }
 
   /* Check if any of ZMM16H-ZMM31H registers are changed.  */
   if ((x86_xcr0 & X86_XSTATE_ZMM))
     {
       int zmm16h_regnum = (num_avx512_zmmh_high_registers == 0
-			   ? -1
-			   : find_regno (regcache->tdesc, "zmm16h"));
+                             ? -1
+                             : find_regno (regcache->tdesc, "zmm16h"));
 
       for (i = 0; i < num_avx512_zmmh_high_registers; i++)
-	{
-	  collect_register (regcache, i + zmm16h_regnum, raw);
-	  p = ((char *) &fp->zmmh_high_space[0]) + 32 + i * 64;
-	  if (memcmp (raw, p, 32) != 0)
-	    {
-	      xstate_bv |= X86_XSTATE_ZMM;
-	      memcpy (p, raw, 32);
-	    }
-	}
+        {
+          collect_register (regcache, i + zmm16h_regnum, raw);
+          p = ((char *) &fp->zmmh_high_space[0]) + 32 + i * 64;
+          if (memcmp (raw, p, 32) != 0)
+            {
+              xstate_bv |= X86_XSTATE_ZMM;
+              memcpy (p, raw, 32);
+            }
+        }
     }
 
   /* Check if any XMM_AVX512 registers are changed.  */
   if ((x86_xcr0 & X86_XSTATE_ZMM))
     {
       int xmm_avx512_regnum = (num_avx512_xmm_registers == 0
-			       ? -1
-			       : find_regno (regcache->tdesc, "xmm16"));
+                                 ? -1
+                                 : find_regno (regcache->tdesc, "xmm16"));
 
       for (i = 0; i < num_avx512_xmm_registers; i++)
-	{
-	  collect_register (regcache, i + xmm_avx512_regnum, raw);
-	  p = ((char *) &fp->zmmh_high_space[0]) + i * 64;
-	  if (memcmp (raw, p, 16) != 0)
-	    {
-	      xstate_bv |= X86_XSTATE_ZMM;
-	      memcpy (p, raw, 16);
-	    }
-	}
+        {
+          collect_register (regcache, i + xmm_avx512_regnum, raw);
+          p = ((char *) &fp->zmmh_high_space[0]) + i * 64;
+          if (memcmp (raw, p, 16) != 0)
+            {
+              xstate_bv |= X86_XSTATE_ZMM;
+              memcpy (p, raw, 16);
+            }
+        }
     }
 
   /* Check if any YMMH_AVX512 registers are changed.  */
   if ((x86_xcr0 & X86_XSTATE_ZMM))
     {
       int ymmh_avx512_regnum = (num_avx512_ymmh_registers == 0
-				? -1
-				: find_regno (regcache->tdesc, "ymm16h"));
+                                  ? -1
+                                  : find_regno (regcache->tdesc, "ymm16h"));
 
       for (i = 0; i < num_avx512_ymmh_registers; i++)
-	{
-	  collect_register (regcache, i + ymmh_avx512_regnum, raw);
-	  p = ((char *) &fp->zmmh_high_space[0]) + 16 + i * 64;
-	  if (memcmp (raw, p, 16) != 0)
-	    {
-	      xstate_bv |= X86_XSTATE_ZMM;
-	      memcpy (p, raw, 16);
-	    }
-	}
+        {
+          collect_register (regcache, i + ymmh_avx512_regnum, raw);
+          p = ((char *) &fp->zmmh_high_space[0]) + 16 + i * 64;
+          if (memcmp (raw, p, 16) != 0)
+            {
+              xstate_bv |= X86_XSTATE_ZMM;
+              memcpy (p, raw, 16);
+            }
+        }
     }
 
   /* Check if any PKEYS registers are changed.  */
@@ -516,98 +519,98 @@ i387_cache_to_xsave (struct regcache *regcache, void *buf)
       int pkru_regnum = find_regno (regcache->tdesc, "pkru");
 
       for (i = 0; i < num_pkeys_registers; i++)
-	{
-	  collect_register (regcache, i + pkru_regnum, raw);
-	  p = ((char *) &fp->pkru_space[0]) + i * 4;
-	  if (memcmp (raw, p, 4) != 0)
-	    {
-	      xstate_bv |= X86_XSTATE_PKRU;
-	      memcpy (p, raw, 4);
-	    }
-	}
+        {
+          collect_register (regcache, i + pkru_regnum, raw);
+          p = ((char *) &fp->pkru_space[0]) + i * 4;
+          if (memcmp (raw, p, 4) != 0)
+            {
+              xstate_bv |= X86_XSTATE_PKRU;
+              memcpy (p, raw, 4);
+            }
+        }
     }
 
   if ((x86_xcr0 & X86_XSTATE_SSE) || (x86_xcr0 & X86_XSTATE_AVX))
     {
       collect_register_by_name (regcache, "mxcsr", raw);
       if (memcmp (raw, &fp->mxcsr, 4) != 0)
-	{
-	  if (((fp->xstate_bv | xstate_bv)
-	       & (X86_XSTATE_SSE | X86_XSTATE_AVX)) == 0)
-	    xstate_bv |= X86_XSTATE_SSE;
-	  memcpy (&fp->mxcsr, raw, 4);
-	}
+        {
+          if (((fp->xstate_bv | xstate_bv) & (X86_XSTATE_SSE | X86_XSTATE_AVX))
+              == 0)
+            xstate_bv |= X86_XSTATE_SSE;
+          memcpy (&fp->mxcsr, raw, 4);
+        }
     }
 
   if (x86_xcr0 & X86_XSTATE_X87)
     {
       collect_register_by_name (regcache, "fioff", raw);
       if (memcmp (raw, &fp->fioff, 4) != 0)
-	{
-	  xstate_bv |= X86_XSTATE_X87;
-	  memcpy (&fp->fioff, raw, 4);
-	}
+        {
+          xstate_bv |= X86_XSTATE_X87;
+          memcpy (&fp->fioff, raw, 4);
+        }
 
       collect_register_by_name (regcache, "fooff", raw);
       if (memcmp (raw, &fp->fooff, 4) != 0)
-	{
-	  xstate_bv |= X86_XSTATE_X87;
-	  memcpy (&fp->fooff, raw, 4);
-	}
+        {
+          xstate_bv |= X86_XSTATE_X87;
+          memcpy (&fp->fooff, raw, 4);
+        }
 
       /* This one's 11 bits... */
       val2 = regcache_raw_get_unsigned_by_name (regcache, "fop");
       val2 = (val2 & 0x7FF) | (fp->fop & 0xF800);
       if (fp->fop != val2)
-	{
-	  xstate_bv |= X86_XSTATE_X87;
-	  fp->fop = val2;
-	}
+        {
+          xstate_bv |= X86_XSTATE_X87;
+          fp->fop = val2;
+        }
 
       /* Some registers are 16-bit.  */
       val = regcache_raw_get_unsigned_by_name (regcache, "fctrl");
       if (fp->fctrl != val)
-	{
-	  xstate_bv |= X86_XSTATE_X87;
-	  fp->fctrl = val;
-	}
+        {
+          xstate_bv |= X86_XSTATE_X87;
+          fp->fctrl = val;
+        }
 
       val = regcache_raw_get_unsigned_by_name (regcache, "fstat");
       if (fp->fstat != val)
-	{
-	  xstate_bv |= X86_XSTATE_X87;
-	  fp->fstat = val;
-	}
+        {
+          xstate_bv |= X86_XSTATE_X87;
+          fp->fstat = val;
+        }
 
       /* Convert to the simplifed tag form stored in fxsave data.  */
       val = regcache_raw_get_unsigned_by_name (regcache, "ftag");
       val2 = 0;
       for (i = 7; i >= 0; i--)
-	{
-	  int tag = (val >> (i * 2)) & 3;
+        {
+          int tag = (val >> (i * 2)) & 3;
 
-	  if (tag != 3)
-	    val2 |= (1 << i);
-	}
+          if (tag != 3)
+            val2 |= (1 << i);
+        }
       if (fp->ftag != val2)
-	{
-	  xstate_bv |= X86_XSTATE_X87;
-	  fp->ftag = val2;
-	}
+        {
+          xstate_bv |= X86_XSTATE_X87;
+          fp->ftag = val2;
+        }
 
       val = regcache_raw_get_unsigned_by_name (regcache, "fiseg");
       if (fp->fiseg != val)
-	{
-	  xstate_bv |= X86_XSTATE_X87;
-	  fp->fiseg = val;
-	}
+        {
+          xstate_bv |= X86_XSTATE_X87;
+          fp->fiseg = val;
+        }
 
       val = regcache_raw_get_unsigned_by_name (regcache, "foseg");
       if (fp->foseg != val)
-	{
-	  xstate_bv |= X86_XSTATE_X87;
-	  fp->foseg = val;
-	}
+        {
+          xstate_bv |= X86_XSTATE_X87;
+          fp->foseg = val;
+        }
     }
 
   /* Update the corresponding bits in xstate_bv if any SSE/AVX
@@ -626,8 +629,8 @@ i387_ftag (struct i387_fxsave *fp, int regno)
   integer = raw[7] & 0x80;
   exponent = (((raw[9] & 0x7f) << 8) | raw[8]);
   fraction[0] = ((raw[3] << 24) | (raw[2] << 16) | (raw[1] << 8) | raw[0]);
-  fraction[1] = (((raw[7] & 0x7f) << 24) | (raw[6] << 16)
-		 | (raw[5] << 8) | raw[4]);
+  fraction[1]
+    = (((raw[7] & 0x7f) << 24) | (raw[6] << 16) | (raw[5] << 8) | raw[4]);
 
   if (exponent == 0x7fff)
     {
@@ -637,28 +640,28 @@ i387_ftag (struct i387_fxsave *fp, int regno)
   else if (exponent == 0x0000)
     {
       if (fraction[0] == 0x0000 && fraction[1] == 0x0000 && !integer)
-	{
-	  /* Zero.  */
-	  return (1);
-	}
+        {
+          /* Zero.  */
+          return (1);
+        }
       else
-	{
-	  /* Special.  */
-	  return (2);
-	}
+        {
+          /* Special.  */
+          return (2);
+        }
     }
   else
     {
       if (integer)
-	{
-	  /* Valid.  */
-	  return (0);
-	}
+        {
+          /* Valid.  */
+          return (0);
+        }
       else
-	{
-	  /* Special.  */
-	  return (2);
-	}
+        {
+          /* Special.  */
+          return (2);
+        }
     }
 }
 
@@ -675,10 +678,10 @@ i387_fxsave_to_cache (struct regcache *regcache, const void *buf)
 
   for (i = 0; i < 8; i++)
     supply_register (regcache, i + st0_regnum,
-		     ((char *) &fp->st_space[0]) + i * 16);
+                     ((char *) &fp->st_space[0]) + i * 16);
   for (i = 0; i < num_xmm_registers; i++)
     supply_register (regcache, i + xmm0_regnum,
-		     ((char *) &fp->xmm_space[0]) + i * 16);
+                     ((char *) &fp->xmm_space[0]) + i * 16);
 
   supply_register_by_name (regcache, "fioff", &fp->fioff);
   supply_register_by_name (regcache, "fooff", &fp->fooff);
@@ -698,9 +701,9 @@ i387_fxsave_to_cache (struct regcache *regcache, const void *buf)
     {
       int tag;
       if (fp->ftag & (1 << i))
-	tag = i387_ftag (fp, (i + 8 - top) % 8);
+        tag = i387_ftag (fp, (i + 8 - top) % 8);
       else
-	tag = 3;
+        tag = 3;
       val |= tag << (2 * i);
     }
   supply_register_by_name (regcache, "ftag", &val);
@@ -726,7 +729,7 @@ i387_xsave_to_cache (struct regcache *regcache, const void *buf)
   unsigned long long clear_bv;
   gdb_byte *p;
 
-   /* Amd64 has 16 xmm regs; I386 has 8 xmm regs.  */
+  /* Amd64 has 16 xmm regs; I386 has 8 xmm regs.  */
   int num_xmm_registers = amd64 ? 16 : 8;
   /* AVX512 extends the existing xmm/ymm registers to a wider mode: zmm.  */
   int num_avx512_zmmh_low_registers = num_xmm_registers;
@@ -745,16 +748,16 @@ i387_xsave_to_cache (struct regcache *regcache, const void *buf)
       int st0_regnum = find_regno (regcache->tdesc, "st0");
 
       if ((clear_bv & X86_XSTATE_X87) != 0)
-	{
-	  for (i = 0; i < 8; i++)
-	    supply_register_zeroed (regcache, i + st0_regnum);
-	}
+        {
+          for (i = 0; i < 8; i++)
+            supply_register_zeroed (regcache, i + st0_regnum);
+        }
       else
-	{
-	  p = (gdb_byte *) &fp->st_space[0];
-	  for (i = 0; i < 8; i++)
-	    supply_register (regcache, i + st0_regnum, p + i * 16);
-	}
+        {
+          p = (gdb_byte *) &fp->st_space[0];
+          for (i = 0; i < 8; i++)
+            supply_register (regcache, i + st0_regnum, p + i * 16);
+        }
     }
 
   if ((x86_xcr0 & X86_XSTATE_SSE) != 0)
@@ -762,16 +765,16 @@ i387_xsave_to_cache (struct regcache *regcache, const void *buf)
       int xmm0_regnum = find_regno (regcache->tdesc, "xmm0");
 
       if ((clear_bv & X86_XSTATE_SSE))
-	{
-	  for (i = 0; i < num_xmm_registers; i++)
-	    supply_register_zeroed (regcache, i + xmm0_regnum);
-	}
+        {
+          for (i = 0; i < num_xmm_registers; i++)
+            supply_register_zeroed (regcache, i + xmm0_regnum);
+        }
       else
-	{
-	  p = (gdb_byte *) &fp->xmm_space[0];
-	  for (i = 0; i < num_xmm_registers; i++)
-	    supply_register (regcache, i + xmm0_regnum, p + i * 16);
-	}
+        {
+          p = (gdb_byte *) &fp->xmm_space[0];
+          for (i = 0; i < num_xmm_registers; i++)
+            supply_register (regcache, i + xmm0_regnum, p + i * 16);
+        }
     }
 
   if ((x86_xcr0 & X86_XSTATE_AVX) != 0)
@@ -779,35 +782,33 @@ i387_xsave_to_cache (struct regcache *regcache, const void *buf)
       int ymm0h_regnum = find_regno (regcache->tdesc, "ymm0h");
 
       if ((clear_bv & X86_XSTATE_AVX) != 0)
-	{
-	  for (i = 0; i < num_xmm_registers; i++)
-	    supply_register_zeroed (regcache, i + ymm0h_regnum);
-	}
+        {
+          for (i = 0; i < num_xmm_registers; i++)
+            supply_register_zeroed (regcache, i + ymm0h_regnum);
+        }
       else
-	{
-	  p = (gdb_byte *) &fp->ymmh_space[0];
-	  for (i = 0; i < num_xmm_registers; i++)
-	    supply_register (regcache, i + ymm0h_regnum, p + i * 16);
-	}
+        {
+          p = (gdb_byte *) &fp->ymmh_space[0];
+          for (i = 0; i < num_xmm_registers; i++)
+            supply_register (regcache, i + ymm0h_regnum, p + i * 16);
+        }
     }
 
   if ((x86_xcr0 & X86_XSTATE_BNDREGS))
     {
       int bnd0r_regnum = find_regno (regcache->tdesc, "bnd0raw");
 
-
       if ((clear_bv & X86_XSTATE_BNDREGS) != 0)
-	{
-	  for (i = 0; i < num_mpx_bnd_registers; i++)
-	    supply_register_zeroed (regcache, i + bnd0r_regnum);
-	}
+        {
+          for (i = 0; i < num_mpx_bnd_registers; i++)
+            supply_register_zeroed (regcache, i + bnd0r_regnum);
+        }
       else
-	{
-	  p = (gdb_byte *) &fp->mpx_bnd_space[0];
-	  for (i = 0; i < num_mpx_bnd_registers; i++)
-	    supply_register (regcache, i + bnd0r_regnum, p + i * 16);
-	}
-
+        {
+          p = (gdb_byte *) &fp->mpx_bnd_space[0];
+          for (i = 0; i < num_mpx_bnd_registers; i++)
+            supply_register (regcache, i + bnd0r_regnum, p + i * 16);
+        }
     }
 
   if ((x86_xcr0 & X86_XSTATE_BNDCFG))
@@ -815,16 +816,16 @@ i387_xsave_to_cache (struct regcache *regcache, const void *buf)
       int bndcfg_regnum = find_regno (regcache->tdesc, "bndcfgu");
 
       if ((clear_bv & X86_XSTATE_BNDCFG) != 0)
-	{
-	  for (i = 0; i < num_mpx_cfg_registers; i++)
-	    supply_register_zeroed (regcache, i + bndcfg_regnum);
-	}
+        {
+          for (i = 0; i < num_mpx_cfg_registers; i++)
+            supply_register_zeroed (regcache, i + bndcfg_regnum);
+        }
       else
-	{
-	  p = (gdb_byte *) &fp->mpx_cfg_space[0];
-	  for (i = 0; i < num_mpx_cfg_registers; i++)
-	    supply_register (regcache, i + bndcfg_regnum, p + i * 8);
-	}
+        {
+          p = (gdb_byte *) &fp->mpx_cfg_space[0];
+          for (i = 0; i < num_mpx_cfg_registers; i++)
+            supply_register (regcache, i + bndcfg_regnum, p + i * 8);
+        }
     }
 
   if ((x86_xcr0 & X86_XSTATE_K) != 0)
@@ -832,16 +833,16 @@ i387_xsave_to_cache (struct regcache *regcache, const void *buf)
       int k0_regnum = find_regno (regcache->tdesc, "k0");
 
       if ((clear_bv & X86_XSTATE_K) != 0)
-	{
-	  for (i = 0; i < num_avx512_k_registers; i++)
-	    supply_register_zeroed (regcache, i + k0_regnum);
-	}
+        {
+          for (i = 0; i < num_avx512_k_registers; i++)
+            supply_register_zeroed (regcache, i + k0_regnum);
+        }
       else
-	{
-	  p = (gdb_byte *) &fp->k_space[0];
-	  for (i = 0; i < num_avx512_k_registers; i++)
-	    supply_register (regcache, i + k0_regnum, p + i * 8);
-	}
+        {
+          p = (gdb_byte *) &fp->k_space[0];
+          for (i = 0; i < num_avx512_k_registers; i++)
+            supply_register (regcache, i + k0_regnum, p + i * 8);
+        }
     }
 
   if ((x86_xcr0 & X86_XSTATE_ZMM_H) != 0)
@@ -849,49 +850,49 @@ i387_xsave_to_cache (struct regcache *regcache, const void *buf)
       int zmm0h_regnum = find_regno (regcache->tdesc, "zmm0h");
 
       if ((clear_bv & X86_XSTATE_ZMM_H) != 0)
-	{
-	  for (i = 0; i < num_avx512_zmmh_low_registers; i++)
-	    supply_register_zeroed (regcache, i + zmm0h_regnum);
-	}
+        {
+          for (i = 0; i < num_avx512_zmmh_low_registers; i++)
+            supply_register_zeroed (regcache, i + zmm0h_regnum);
+        }
       else
-	{
-	  p = (gdb_byte *) &fp->zmmh_low_space[0];
-	  for (i = 0; i < num_avx512_zmmh_low_registers; i++)
-	    supply_register (regcache, i + zmm0h_regnum, p + i * 32);
-	}
+        {
+          p = (gdb_byte *) &fp->zmmh_low_space[0];
+          for (i = 0; i < num_avx512_zmmh_low_registers; i++)
+            supply_register (regcache, i + zmm0h_regnum, p + i * 32);
+        }
     }
 
   if ((x86_xcr0 & X86_XSTATE_ZMM) != 0)
     {
       int zmm16h_regnum = (num_avx512_zmmh_high_registers == 0
-			   ? -1
-			   : find_regno (regcache->tdesc, "zmm16h"));
+                             ? -1
+                             : find_regno (regcache->tdesc, "zmm16h"));
       int ymm16h_regnum = (num_avx512_ymmh_registers == 0
-			   ? -1
-			   : find_regno (regcache->tdesc, "ymm16h"));
+                             ? -1
+                             : find_regno (regcache->tdesc, "ymm16h"));
       int xmm16_regnum = (num_avx512_xmm_registers == 0
-			  ? -1
-			  : find_regno (regcache->tdesc, "xmm16"));
+                            ? -1
+                            : find_regno (regcache->tdesc, "xmm16"));
 
       if ((clear_bv & X86_XSTATE_ZMM) != 0)
-	{
-	  for (i = 0; i < num_avx512_zmmh_high_registers; i++)
-	    supply_register_zeroed (regcache, i + zmm16h_regnum);
-	  for (i = 0; i < num_avx512_ymmh_registers; i++)
-	    supply_register_zeroed (regcache, i + ymm16h_regnum);
-	  for (i = 0; i < num_avx512_xmm_registers; i++)
-	    supply_register_zeroed (regcache, i + xmm16_regnum);
-	}
+        {
+          for (i = 0; i < num_avx512_zmmh_high_registers; i++)
+            supply_register_zeroed (regcache, i + zmm16h_regnum);
+          for (i = 0; i < num_avx512_ymmh_registers; i++)
+            supply_register_zeroed (regcache, i + ymm16h_regnum);
+          for (i = 0; i < num_avx512_xmm_registers; i++)
+            supply_register_zeroed (regcache, i + xmm16_regnum);
+        }
       else
-	{
-	  p = (gdb_byte *) &fp->zmmh_high_space[0];
-	  for (i = 0; i < num_avx512_zmmh_high_registers; i++)
-	    supply_register (regcache, i + zmm16h_regnum, p + 32 + i * 64);
-	  for (i = 0; i < num_avx512_ymmh_registers; i++)
-	    supply_register (regcache, i + ymm16h_regnum, p + 16 + i * 64);
-	  for (i = 0; i < num_avx512_xmm_registers; i++)
-	    supply_register (regcache, i + xmm16_regnum, p + i * 64);
-	}
+        {
+          p = (gdb_byte *) &fp->zmmh_high_space[0];
+          for (i = 0; i < num_avx512_zmmh_high_registers; i++)
+            supply_register (regcache, i + zmm16h_regnum, p + 32 + i * 64);
+          for (i = 0; i < num_avx512_ymmh_registers; i++)
+            supply_register (regcache, i + ymm16h_regnum, p + 16 + i * 64);
+          for (i = 0; i < num_avx512_xmm_registers; i++)
+            supply_register (regcache, i + xmm16_regnum, p + i * 64);
+        }
     }
 
   if ((x86_xcr0 & X86_XSTATE_PKRU) != 0)
@@ -899,16 +900,16 @@ i387_xsave_to_cache (struct regcache *regcache, const void *buf)
       int pkru_regnum = find_regno (regcache->tdesc, "pkru");
 
       if ((clear_bv & X86_XSTATE_PKRU) != 0)
-	{
-	  for (i = 0; i < num_pkeys_registers; i++)
-	    supply_register_zeroed (regcache, i + pkru_regnum);
-	}
+        {
+          for (i = 0; i < num_pkeys_registers; i++)
+            supply_register_zeroed (regcache, i + pkru_regnum);
+        }
       else
-	{
-	  p = (gdb_byte *) &fp->pkru_space[0];
-	  for (i = 0; i < num_pkeys_registers; i++)
-	    supply_register (regcache, i + pkru_regnum, p + i * 4);
-	}
+        {
+          p = (gdb_byte *) &fp->pkru_space[0];
+          for (i = 0; i < num_pkeys_registers; i++)
+            supply_register (regcache, i + pkru_regnum, p + i * 4);
+        }
     }
 
   if ((clear_bv & (X86_XSTATE_SSE | X86_XSTATE_AVX))
@@ -953,14 +954,14 @@ i387_xsave_to_cache (struct regcache *regcache, const void *buf)
       top = (fp->fstat >> 11) & 0x7;
       val = 0;
       for (i = 7; i >= 0; i--)
-	{
-	  int tag;
-	  if (fp->ftag & (1 << i))
-	    tag = i387_ftag (fxp, (i + 8 - top) % 8);
-	  else
-	    tag = 3;
-	  val |= tag << (2 * i);
-	}
+        {
+          int tag;
+          if (fp->ftag & (1 << i))
+            tag = i387_ftag (fxp, (i + 8 - top) % 8);
+          else
+            tag = 3;
+          val |= tag << (2 * i);
+        }
       supply_register_by_name (regcache, "ftag", &val);
 
       val = fp->fiseg & 0xFFFF;