Remove regcache_raw_collect

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

diff --git a/gdb/sparc64-tdep.c b/gdb/sparc64-tdep.c
index 083ad72afd1b09845858c9f0fc1326d30bb84328..86b5fcf47bf9d2819bad3cc34be15037ed1a97ff 100644 (file)
--- a/gdb/sparc64-tdep.c
+++ b/gdb/sparc64-tdep.c
@@ -2010,7 +2010,7 @@ sparc64_collect_gregset (const struct sparc_gregmap *gregmap,
          gdb_byte buf[8];
 
          tstate = extract_unsigned_integer (regs + offset, 8, byte_order);
-         regcache_raw_collect (regcache, SPARC32_PSR_REGNUM, buf);
+         regcache->raw_collect (SPARC32_PSR_REGNUM, buf);
          psr = extract_unsigned_integer (buf, 4, byte_order);
          tstate |= (psr & PSR_ICC) << 12;
          if ((psr & (PSR_VERS | PSR_IMPL)) == PSR_V8PLUS)
@@ -2020,46 +2020,46 @@ sparc64_collect_gregset (const struct sparc_gregmap *gregmap,
        }
 
       if (regnum == SPARC32_PC_REGNUM || regnum == -1)
-       regcache_raw_collect (regcache, SPARC32_PC_REGNUM,
-                             regs + gregmap->r_pc_offset + 4);
+       regcache->raw_collect (SPARC32_PC_REGNUM,
+                              regs + gregmap->r_pc_offset + 4);
 
       if (regnum == SPARC32_NPC_REGNUM || regnum == -1)
-       regcache_raw_collect (regcache, SPARC32_NPC_REGNUM,
-                             regs + gregmap->r_npc_offset + 4);
+       regcache->raw_collect (SPARC32_NPC_REGNUM,
+                              regs + gregmap->r_npc_offset + 4);
 
       if (regnum == SPARC32_Y_REGNUM || regnum == -1)
        {
          int offset = gregmap->r_y_offset + 8 - gregmap->r_y_size;
-         regcache_raw_collect (regcache, SPARC32_Y_REGNUM, regs + offset);
+         regcache->raw_collect (SPARC32_Y_REGNUM, regs + offset);
        }
     }
   else
     {
       if (regnum == SPARC64_STATE_REGNUM || regnum == -1)
-       regcache_raw_collect (regcache, SPARC64_STATE_REGNUM,
-                             regs + gregmap->r_tstate_offset);
+       regcache->raw_collect (SPARC64_STATE_REGNUM,
+                              regs + gregmap->r_tstate_offset);
 
       if (regnum == SPARC64_PC_REGNUM || regnum == -1)
-       regcache_raw_collect (regcache, SPARC64_PC_REGNUM,
-                             regs + gregmap->r_pc_offset);
+       regcache->raw_collect (SPARC64_PC_REGNUM,
+                              regs + gregmap->r_pc_offset);
 
       if (regnum == SPARC64_NPC_REGNUM || regnum == -1)
-       regcache_raw_collect (regcache, SPARC64_NPC_REGNUM,
-                             regs + gregmap->r_npc_offset);
+       regcache->raw_collect (SPARC64_NPC_REGNUM,
+                              regs + gregmap->r_npc_offset);
 
       if (regnum == SPARC64_Y_REGNUM || regnum == -1)
        {
          gdb_byte buf[8];
 
-         regcache_raw_collect (regcache, SPARC64_Y_REGNUM, buf);
+         regcache->raw_collect (SPARC64_Y_REGNUM, buf);
          memcpy (regs + gregmap->r_y_offset,
                  buf + 8 - gregmap->r_y_size, gregmap->r_y_size);
        }
 
       if ((regnum == SPARC64_FPRS_REGNUM || regnum == -1)
          && gregmap->r_fprs_offset != -1)
-       regcache_raw_collect (regcache, SPARC64_FPRS_REGNUM,
-                             regs + gregmap->r_fprs_offset);
+       regcache->raw_collect (SPARC64_FPRS_REGNUM,
+                              regs + gregmap->r_fprs_offset);
 
     }
 
@@ -2074,7 +2074,7 @@ sparc64_collect_gregset (const struct sparc_gregmap *gregmap,
       for (i = SPARC_G1_REGNUM; i <= SPARC_O7_REGNUM; i++)
        {
          if (regnum == i || regnum == -1)
-           regcache_raw_collect (regcache, i, regs + offset);
+           regcache->raw_collect (i, regs + offset);
          offset += 8;
        }
     }
@@ -2093,7 +2093,7 @@ sparc64_collect_gregset (const struct sparc_gregmap *gregmap,
          for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)
            {
              if (regnum == i || regnum == -1)
-               regcache_raw_collect (regcache, i, regs + offset);
+               regcache->raw_collect (i, regs + offset);
              offset += 8;
            }
        }
@@ -2113,7 +2113,7 @@ sparc64_supply_fpregset (const struct sparc_fpregmap *fpregmap,
     {
       if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1)
        regcache->raw_supply (SPARC_F0_REGNUM + i,
-                            regs + fpregmap->r_f0_offset + (i * 4));
+                             regs + fpregmap->r_f0_offset + (i * 4));
     }
 
   if (sparc32)
@@ -2150,29 +2150,29 @@ sparc64_collect_fpregset (const struct sparc_fpregmap *fpregmap,
   for (i = 0; i < 32; i++)
     {
       if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1)
-       regcache_raw_collect (regcache, SPARC_F0_REGNUM + i,
-                             regs + fpregmap->r_f0_offset + (i * 4));
+       regcache->raw_collect (SPARC_F0_REGNUM + i,
+                              regs + fpregmap->r_f0_offset + (i * 4));
     }
 
   if (sparc32)
     {
       if (regnum == SPARC32_FSR_REGNUM || regnum == -1)
-       regcache_raw_collect (regcache, SPARC32_FSR_REGNUM,
-                             regs + fpregmap->r_fsr_offset);
+       regcache->raw_collect (SPARC32_FSR_REGNUM,
+                              regs + fpregmap->r_fsr_offset);
     }
   else
     {
       for (i = 0; i < 16; i++)
        {
          if (regnum == (SPARC64_F32_REGNUM + i) || regnum == -1)
-           regcache_raw_collect (regcache, SPARC64_F32_REGNUM + i,
-                                 (regs + fpregmap->r_f0_offset
-                                  + (32 * 4) + (i * 8)));
+           regcache->raw_collect (SPARC64_F32_REGNUM + i,
+                                  (regs + fpregmap->r_f0_offset
+                                   + (32 * 4) + (i * 8)));
        }
 
       if (regnum == SPARC64_FSR_REGNUM || regnum == -1)
-       regcache_raw_collect (regcache, SPARC64_FSR_REGNUM,
-                             regs + fpregmap->r_fsr_offset);
+       regcache->raw_collect (SPARC64_FSR_REGNUM,
+                              regs + fpregmap->r_fsr_offset);
     }
 }