Remove regcache_raw_read

Remove regcache_raw_read, update all callers to use
readable_regcache::raw_read instead.

gdb/ChangeLog:

	* regcache.h (regcache_raw_read): Remove, update callers to use
	readable_regcache::raw_read instead.
	* regcache.c (regcache_raw_read): Remove.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 4f451a2910e5424e16fb2585704eebc72a7862ec..4b7bfada9dcee14c925c8cea9b52a5c19aee02c9 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,9 @@
+2018-05-30  Simon Marchi  <simon.marchi@ericsson.com>
+
+       * regcache.h (regcache_raw_read): Remove, update callers to use
+       readable_regcache::raw_read instead.
+       * regcache.c (regcache_raw_read): Remove.
+
 2018-05-30  Simon Marchi  <simon.marchi@ericsson.com>
 
        * regcache.h (regcache_raw_update): Remove, update callers to

diff --git a/gdb/amd64-tdep.c b/gdb/amd64-tdep.c
index d555465c2f9646fd829652741c44ce917d8b602b..0eac35e536bdf28036f1e860c0252c7b7b092e68 100644 (file)
--- a/gdb/amd64-tdep.c
+++ b/gdb/amd64-tdep.c
@@ -422,8 +422,7 @@ amd64_pseudo_register_write (struct gdbarch *gdbarch,
       if (gpnum >= AMD64_NUM_LOWER_BYTE_REGS)
        {
          /* Read ... AH, BH, CH, DH.  */
-         regcache_raw_read (regcache,
-                            gpnum - AMD64_NUM_LOWER_BYTE_REGS, raw_buf);
+         regcache->raw_read (gpnum - AMD64_NUM_LOWER_BYTE_REGS, raw_buf);
          /* ... Modify ... (always little endian).  */
          memcpy (raw_buf + 1, buf, 1);
          /* ... Write.  */
@@ -433,7 +432,7 @@ amd64_pseudo_register_write (struct gdbarch *gdbarch,
       else
        {
          /* Read ...  */
-         regcache_raw_read (regcache, gpnum, raw_buf);
+         regcache->raw_read (gpnum, raw_buf);
          /* ... Modify ... (always little endian).  */
          memcpy (raw_buf, buf, 1);
          /* ... Write.  */
@@ -445,7 +444,7 @@ amd64_pseudo_register_write (struct gdbarch *gdbarch,
       int gpnum = regnum - tdep->eax_regnum;
 
       /* Read ...  */
-      regcache_raw_read (regcache, gpnum, raw_buf);
+      regcache->raw_read (gpnum, raw_buf);
       /* ... Modify ... (always little endian).  */
       memcpy (raw_buf, buf, 4);
       /* ... Write.  */
@@ -771,8 +770,8 @@ amd64_return_value (struct gdbarch *gdbarch, struct value *function,
     {
       if (readbuf)
        {
-         regcache_raw_read (regcache, AMD64_ST0_REGNUM, readbuf);
-         regcache_raw_read (regcache, AMD64_ST1_REGNUM, readbuf + 16);
+         regcache->raw_read (AMD64_ST0_REGNUM, readbuf);
+         regcache->raw_read (AMD64_ST1_REGNUM, readbuf + 16);
        }
 
       if (writebuf)

diff --git a/gdb/arm-tdep.c b/gdb/arm-tdep.c
index 382080a714b66624fc7064a022284eac0de54634..7fa0db38e1cdc462a6b1cff2a265d3e1cec58b1e 100644 (file)
--- a/gdb/arm-tdep.c
+++ b/gdb/arm-tdep.c
@@ -8800,7 +8800,7 @@ arm_pseudo_write (struct gdbarch *gdbarch, struct regcache *regcache,
       double_regnum = user_reg_map_name_to_regnum (gdbarch, name_buf,
                                                   strlen (name_buf));
 
-      regcache_raw_read (regcache, double_regnum, reg_buf);
+      regcache->raw_read (double_regnum, reg_buf);
       memcpy (reg_buf + offset, buf, 4);
       regcache_raw_write (regcache, double_regnum, reg_buf);
     }

diff --git a/gdb/bfin-tdep.c b/gdb/bfin-tdep.c
index 63fbf6209e2c86dcdeea54e6c0b510f0f3599ff6..66a94653791102059234726f5fa1ec947b11dd39 100644 (file)
--- a/gdb/bfin-tdep.c
+++ b/gdb/bfin-tdep.c
@@ -719,7 +719,7 @@ bfin_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
                    _("invalid register number %d"), regnum);
 
   /* Overlay the CC bit in the ASTAT register.  */
-  regcache_raw_read (regcache, BFIN_ASTAT_REGNUM, buf);
+  regcache->raw_read (BFIN_ASTAT_REGNUM, buf);
   buf[0] = (buf[0] & ~ASTAT_CC) | ((buffer[0] & 1) << ASTAT_CC_POS);
   regcache_raw_write (regcache, BFIN_ASTAT_REGNUM, buf);
 }

diff --git a/gdb/frv-tdep.c b/gdb/frv-tdep.c
index 2f9a8d27c46a2971f315b67a24822c588ab29cf1..04bb43ba016356a59610d79b596e31c835c229b5 100644 (file)
--- a/gdb/frv-tdep.c
+++ b/gdb/frv-tdep.c
@@ -349,7 +349,7 @@ frv_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
       int byte_num = (reg - accg0_regnum) % 4;
       gdb_byte buf[4];
 
-      regcache_raw_read (regcache, raw_regnum, buf);
+      regcache->raw_read (raw_regnum, buf);
       buf[byte_num] = ((bfd_byte *) buffer)[0];
       regcache_raw_write (regcache, raw_regnum, buf);
     }

diff --git a/gdb/i386-tdep.c b/gdb/i386-tdep.c
index 646f305edc5146adfaac9e36a0ff5392682b8867..0a4e4d7c1ca0f9cddaed27acdba0fb813683f900 100644 (file)
--- a/gdb/i386-tdep.c
+++ b/gdb/i386-tdep.c
@@ -2802,7 +2802,7 @@ i386_extract_return_value (struct gdbarch *gdbarch, struct type *type,
         its contents to the desired type.  This is probably not
         exactly how it would happen on the target itself, but it is
         the best we can do.  */
-      regcache_raw_read (regcache, I386_ST0_REGNUM, buf);
+      regcache->raw_read (I386_ST0_REGNUM, buf);
       target_float_convert (buf, i387_ext_type (gdbarch), valbuf, type);
     }
   else
@@ -2812,14 +2812,14 @@ i386_extract_return_value (struct gdbarch *gdbarch, struct type *type,
 
       if (len <= low_size)
        {
-         regcache_raw_read (regcache, LOW_RETURN_REGNUM, buf);
+         regcache->raw_read (LOW_RETURN_REGNUM, buf);
          memcpy (valbuf, buf, len);
        }
       else if (len <= (low_size + high_size))
        {
-         regcache_raw_read (regcache, LOW_RETURN_REGNUM, buf);
+         regcache->raw_read (LOW_RETURN_REGNUM, buf);
          memcpy (valbuf, buf, low_size);
-         regcache_raw_read (regcache, HIGH_RETURN_REGNUM, buf);
+         regcache->raw_read (HIGH_RETURN_REGNUM, buf);
          memcpy (valbuf + low_size, buf, len - low_size);
        }
       else
@@ -3474,7 +3474,7 @@ i386_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
       int fpnum = i386_mmx_regnum_to_fp_regnum (regcache, regnum);
 
       /* Read ...  */
-      regcache_raw_read (regcache, fpnum, raw_buf);
+      regcache->raw_read (fpnum, raw_buf);
       /* ... Modify ... (always little endian).  */
       memcpy (raw_buf, buf, register_size (gdbarch, regnum));
       /* ... Write.  */
@@ -3496,9 +3496,8 @@ i386_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
          upper = extract_unsigned_integer (buf + size, size, byte_order);
 
          /* Fetching register buffer.  */
-         regcache_raw_read (regcache,
-                            I387_BND0R_REGNUM (tdep) + regnum,
-                            raw_buf);
+         regcache->raw_read (I387_BND0R_REGNUM (tdep) + regnum,
+                             raw_buf);
 
          upper = ~upper;
 
@@ -3583,7 +3582,7 @@ i386_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
          int gpnum = regnum - tdep->ax_regnum;
 
          /* Read ...  */
-         regcache_raw_read (regcache, gpnum, raw_buf);
+         regcache->raw_read (gpnum, raw_buf);
          /* ... Modify ... (always little endian).  */
          memcpy (raw_buf, buf, 2);
          /* ... Write.  */
@@ -3594,7 +3593,7 @@ i386_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
          int gpnum = regnum - tdep->al_regnum;
 
          /* Read ...  We read both lower and upper registers.  */
-         regcache_raw_read (regcache, gpnum % 4, raw_buf);
+         regcache->raw_read (gpnum % 4, raw_buf);
          /* ... Modify ... (always little endian).  */
          if (gpnum >= 4)
            memcpy (raw_buf + 1, buf, 1);

diff --git a/gdb/m68hc11-tdep.c b/gdb/m68hc11-tdep.c
index d6f3593f6e1ed7a04c7afd1cc0a882ae8b7af9b4..bce95e9c68c1c73032eefe49a97a56ea262f8789 100644 (file)
--- a/gdb/m68hc11-tdep.c
+++ b/gdb/m68hc11-tdep.c
@@ -1280,7 +1280,7 @@ m68hc11_extract_return_value (struct type *type, struct regcache *regcache,
 {
   gdb_byte buf[M68HC11_REG_SIZE];
 
-  regcache_raw_read (regcache, HARD_D_REGNUM, buf);
+  regcache->raw_read (HARD_D_REGNUM, buf);
   switch (TYPE_LENGTH (type))
     {
     case 1:
@@ -1293,13 +1293,13 @@ m68hc11_extract_return_value (struct type *type, struct regcache *regcache,
 
     case 3:
       memcpy ((char*) valbuf + 1, buf, 2);
-      regcache_raw_read (regcache, HARD_X_REGNUM, buf);
+      regcache->raw_read (HARD_X_REGNUM, buf);
       memcpy (valbuf, buf + 1, 1);
       break;
 
     case 4:
       memcpy ((char*) valbuf + 2, buf, 2);
-      regcache_raw_read (regcache, HARD_X_REGNUM, buf);
+      regcache->raw_read (HARD_X_REGNUM, buf);
       memcpy (valbuf, buf, 2);
       break;
 

diff --git a/gdb/m68k-tdep.c b/gdb/m68k-tdep.c
index b9fa5e6d4cf81cca5c2f851c9d96ac097c75b624..a6a1bb498b2a822fa633d6577005bb07c21fc3af 100644 (file)
--- a/gdb/m68k-tdep.c
+++ b/gdb/m68k-tdep.c
@@ -286,14 +286,14 @@ m68k_extract_return_value (struct type *type, struct regcache *regcache,
 
   if (len <= 4)
     {
-      regcache_raw_read (regcache, M68K_D0_REGNUM, buf);
+      regcache->raw_read (M68K_D0_REGNUM, buf);
       memcpy (valbuf, buf + (4 - len), len);
     }
   else if (len <= 8)
     {
-      regcache_raw_read (regcache, M68K_D0_REGNUM, buf);
+      regcache->raw_read (M68K_D0_REGNUM, buf);
       memcpy (valbuf, buf + (8 - len), len - 4);
-      regcache_raw_read (regcache, M68K_D1_REGNUM, valbuf + (len - 4));
+      regcache->raw_read (M68K_D1_REGNUM, valbuf + (len - 4));
     }
   else
     internal_error (__FILE__, __LINE__,
@@ -311,11 +311,11 @@ m68k_svr4_extract_return_value (struct type *type, struct regcache *regcache,
   if (tdep->float_return && TYPE_CODE (type) == TYPE_CODE_FLT)
     {
       struct type *fpreg_type = register_type (gdbarch, M68K_FP0_REGNUM);
-      regcache_raw_read (regcache, M68K_FP0_REGNUM, buf);
+      regcache->raw_read (M68K_FP0_REGNUM, buf);
       target_float_convert (buf, fpreg_type, valbuf, type);
     }
   else if (TYPE_CODE (type) == TYPE_CODE_PTR && TYPE_LENGTH (type) == 4)
-    regcache_raw_read (regcache, M68K_A0_REGNUM, valbuf);
+    regcache->raw_read (M68K_A0_REGNUM, valbuf);
   else
     m68k_extract_return_value (type, regcache, valbuf);
 }

diff --git a/gdb/mn10300-tdep.c b/gdb/mn10300-tdep.c
index e12e01df03037174c3234414ab1a8e2e9b0a6ae4..c8267cfd28614385a24a2ba978fd8d5fcabe6cd4 100644 (file)
--- a/gdb/mn10300-tdep.c
+++ b/gdb/mn10300-tdep.c
@@ -212,15 +212,15 @@ mn10300_extract_return_value (struct gdbarch *gdbarch, struct type *type,
   gdb_assert (regsz <= MN10300_MAX_REGISTER_SIZE);
   if (len <= regsz)
     {
-      regcache_raw_read (regcache, reg, buf);
+      regcache->raw_read (reg, buf);
       memcpy (valbuf, buf, len);
     }
   else if (len <= 2 * regsz)
     {
-      regcache_raw_read (regcache, reg, buf);
+      regcache->raw_read (reg, buf);
       memcpy (valbuf, buf, regsz);
       gdb_assert (regsz == register_size (gdbarch, reg + 1));
-      regcache_raw_read (regcache, reg + 1, buf);
+      regcache->raw_read (reg + 1, buf);
       memcpy ((char *) valbuf + regsz, buf, len - regsz);
     }
   else

diff --git a/gdb/moxie-tdep.c b/gdb/moxie-tdep.c
index 50cacfef972e0d70fe65f601af384f0c013350b8..078ff391e0bb199702003e055699fce5ae8d05a6 100644 (file)
--- a/gdb/moxie-tdep.c
+++ b/gdb/moxie-tdep.c
@@ -433,8 +433,7 @@ moxie_software_single_step (struct regcache *regcache)
 
        case 0x19: /* jsr */
        case 0x25: /* jmp */
-         regcache_raw_read (regcache,
-                            (inst >> 4) & 0xf, (gdb_byte *) & tmpu32);
+         regcache->raw_read ((inst >> 4) & 0xf, (gdb_byte *) & tmpu32);
          next_pcs.push_back (tmpu32);
          break;
 
@@ -734,7 +733,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
          break;
        case 0x03: /* jsra */
          {
-           regcache_raw_read (regcache, 
+           regcache->raw_read (
                               MOXIE_SP_REGNUM, (gdb_byte *) & tmpu32);
            tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 
                                               4, byte_order);
@@ -763,7 +762,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
        case 0x06: /* push */
          {
            int reg = (inst >> 4) & 0xf;
-           regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
+           regcache->raw_read (reg, (gdb_byte *) & tmpu32);
            tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 
                                               4, byte_order);
            if (record_full_arch_list_add_reg (regcache, reg)
@@ -805,7 +804,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
        case 0x0b: /* st.l */
          {
            int reg = (inst >> 4) & 0xf;
-           regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
+           regcache->raw_read (reg, (gdb_byte *) & tmpu32);
            tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 
                                               4, byte_order);
            if (record_full_arch_list_add_mem (tmpu32, 4))
@@ -824,7 +823,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
            int reg = (inst >> 4) & 0xf;
            uint32_t offset = (((int16_t) moxie_process_readu (addr+2, buf, 2,
                                                               byte_order)) << 16 ) >> 16;
-           regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
+           regcache->raw_read (reg, (gdb_byte *) & tmpu32);
            tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 
                                               4, byte_order);
            tmpu32 += offset;
@@ -864,7 +863,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
          }
        case 0x19: /* jsr */
          {
-           regcache_raw_read (regcache, 
+           regcache->raw_read (
                               MOXIE_SP_REGNUM, (gdb_byte *) & tmpu32);
            tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 
                                               4, byte_order);
@@ -892,7 +891,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
        case 0x1e: /* st.b */
          {
            int reg = (inst >> 4) & 0xf;
-           regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
+           regcache->raw_read (reg, (gdb_byte *) & tmpu32);
            tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 
                                               4, byte_order);
            if (record_full_arch_list_add_mem (tmpu32, 1))
@@ -918,7 +917,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
        case 0x23: /* st.s */
          {
            int reg = (inst >> 4) & 0xf;
-           regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
+           regcache->raw_read (reg, (gdb_byte *) & tmpu32);
            tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 
                                               4, byte_order);
            if (record_full_arch_list_add_mem (tmpu32, 2))
@@ -978,12 +977,12 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
                  uint32_t length, ptr;
 
                  /* Read buffer pointer is in $r1.  */
-                 regcache_raw_read (regcache, 3, (gdb_byte *) & ptr);
+                 regcache->raw_read (3, (gdb_byte *) & ptr);
                  ptr = extract_unsigned_integer ((gdb_byte *) & ptr, 
                                                  4, byte_order);
 
                  /* String length is at 0x12($fp).  */
-                 regcache_raw_read (regcache, 
+                 regcache->raw_read (
                                     MOXIE_FP_REGNUM, (gdb_byte *) & tmpu32);
                  tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 
                                                     4, byte_order);
@@ -1029,7 +1028,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
            int reg = (inst >> 4) & 0xf;
            uint32_t offset = (((int16_t) moxie_process_readu (addr+2, buf, 2,
                                                               byte_order)) << 16 ) >> 16;
-           regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
+           regcache->raw_read (reg, (gdb_byte *) & tmpu32);
            tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 
                                               4, byte_order);
            tmpu32 += offset;
@@ -1049,7 +1048,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
            int reg = (inst >> 4) & 0xf;
            uint32_t offset = (((int16_t) moxie_process_readu (addr+2, buf, 2,
                                                               byte_order)) << 16 ) >> 16;
-           regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
+           regcache->raw_read (reg, (gdb_byte *) & tmpu32);
            tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 
                                               4, byte_order);
            tmpu32 += offset;

diff --git a/gdb/nds32-tdep.c b/gdb/nds32-tdep.c
index 8cc9d5bc84c67720af75c68e67634c0e30db497b..991a870c74647f4f61b499bb1ebc9a332391ffc5 100644 (file)
--- a/gdb/nds32-tdep.c
+++ b/gdb/nds32-tdep.c
@@ -500,7 +500,7 @@ nds32_pseudo_register_write (struct gdbarch *gdbarch,
        offset = (regnum & 1) ? 0 : 4;
 
       fdr_regnum = NDS32_FD0_REGNUM + (regnum >> 1);
-      regcache_raw_read (regcache, fdr_regnum, reg_buf);
+      regcache->raw_read (fdr_regnum, reg_buf);
       memcpy (reg_buf + offset, buf, 4);
       regcache_raw_write (regcache, fdr_regnum, reg_buf);
       return;

diff --git a/gdb/record-full.c b/gdb/record-full.c
index 79f5c0fa0a64079628ef5ff836c489a00b998f1b..9b670076e7e7e09fab214b8cbfb5a0bda8ffddd0 100644 (file)
--- a/gdb/record-full.c
+++ b/gdb/record-full.c
@@ -620,7 +620,7 @@ record_full_arch_list_add_reg (struct regcache *regcache, int regnum)
 
   rec = record_full_reg_alloc (regcache, regnum);
 
-  regcache_raw_read (regcache, regnum, record_full_get_loc (rec));
+  regcache->raw_read (regnum, record_full_get_loc (rec));
 
   record_full_arch_list_add (rec);
 

diff --git a/gdb/regcache.c b/gdb/regcache.c
index 64d167a3894fa66df51b522e2492a01eee21eea4..555140879c7a099dc0c34d1f681716d24110e4a2 100644 (file)
--- a/gdb/regcache.c
+++ b/gdb/regcache.c
@@ -510,12 +510,6 @@ regcache::raw_update (int regnum)
     }
 }
 
-enum register_status
-regcache_raw_read (struct regcache *regcache, int regnum, gdb_byte *buf)
-{
-  return regcache->raw_read (regnum, buf);
-}
-
 enum register_status
 readable_regcache::raw_read (int regnum, gdb_byte *buf)
 {

diff --git a/gdb/regcache.h b/gdb/regcache.h
index dffc27f17c1cec88e355497a691361ce9dbb3272..37358522db51054b5a5df93154002e9dcff3df97 100644 (file)
--- a/gdb/regcache.h
+++ b/gdb/regcache.h
@@ -38,8 +38,6 @@ extern struct regcache *get_thread_arch_aspace_regcache (ptid_t,
 /* Transfer a raw register [0..NUM_REGS) between core-gdb and the
    regcache.  The read variants return the status of the register.  */
 
-enum register_status regcache_raw_read (struct regcache *regcache,
-                                       int rawnum, gdb_byte *buf);
 void regcache_raw_write (struct regcache *regcache, int rawnum,
                         const gdb_byte *buf);
 extern enum register_status
@@ -246,6 +244,9 @@ public:
     : reg_buffer (gdbarch, has_pseudo)
   {}
 
+  /* Transfer a raw register [0..NUM_REGS) from core-gdb to this regcache,
+     return its value in *BUF and return its availability status.  */
+
   enum register_status raw_read (int regnum, gdb_byte *buf);
   template<typename T, typename = RequireLongest<T>>
   enum register_status raw_read (int regnum, T *val);

diff --git a/gdb/s390-tdep.c b/gdb/s390-tdep.c
index 4af035fbfcd482efbfc0e26ba0a5c1a8e6de9dbb..aecdbbdf9c1e8a6342b0f0f7943595f6b65af893 100644 (file)
--- a/gdb/s390-tdep.c
+++ b/gdb/s390-tdep.c
@@ -2816,7 +2816,7 @@ s390_record_calc_disp_vsce (struct gdbarch *gdbarch, struct regcache *regcache,
   if (vx < 16)
     regcache_cooked_read (regcache, tdep->v0_full_regnum + vx, buf);
   else
-    regcache_raw_read (regcache, S390_V16_REGNUM + vx - 16, buf);
+    regcache->raw_read (S390_V16_REGNUM + vx - 16, buf);
   x = extract_unsigned_integer (buf + el * es, es, byte_order);
   *res = s390_record_calc_disp_common (gdbarch, regcache, x, bd, dh);
   return 0;

diff --git a/gdb/sh-tdep.c b/gdb/sh-tdep.c
index edf7e94b2ea58233ddadd37fb238b472c93bc1fd..c9439f8fc0a107a8179e1f5d791470520b815ea7 100644 (file)
--- a/gdb/sh-tdep.c
+++ b/gdb/sh-tdep.c
@@ -1324,7 +1324,7 @@ sh_extract_return_value_nofpu (struct type *type, struct regcache *regcache,
     {
       int i, regnum = R0_REGNUM;
       for (i = 0; i < len; i += 4)
-       regcache_raw_read (regcache, regnum++, valbuf + i);
+       regcache->raw_read (regnum++, valbuf + i);
     }
   else
     error (_("bad size for return value"));
@@ -1341,10 +1341,10 @@ sh_extract_return_value_fpu (struct type *type, struct regcache *regcache,
       int i, regnum = gdbarch_fp0_regnum (gdbarch);
       for (i = 0; i < len; i += 4)
        if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
-         regcache_raw_read (regcache, regnum++,
+         regcache->raw_read (regnum++,
                             valbuf + len - 4 - i);
        else
-         regcache_raw_read (regcache, regnum++, valbuf + i);
+         regcache->raw_read (regnum++, valbuf + i);
     }
   else
     sh_extract_return_value_nofpu (type, regcache, valbuf);

diff --git a/gdb/spu-tdep.c b/gdb/spu-tdep.c
index 2567c240d450fc75377c68546b320f8d671ab3f0..fd6d098c24478d893378877128e11f381c34ad43 100644 (file)
--- a/gdb/spu-tdep.c
+++ b/gdb/spu-tdep.c
@@ -278,7 +278,7 @@ spu_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
   switch (regnum)
     {
     case SPU_SP_REGNUM:
-      regcache_raw_read (regcache, SPU_RAW_SP_REGNUM, reg);
+      regcache->raw_read (SPU_RAW_SP_REGNUM, reg);
       memcpy (reg, buf, 4);
       regcache_raw_write (regcache, SPU_RAW_SP_REGNUM, reg);
       break;

diff --git a/gdb/tilegx-tdep.c b/gdb/tilegx-tdep.c
index 8f688b16cf03f2c6b347396865931db826797ee8..e11ecdd15a718f6aee4fccb0eec415f647f441e3 100644 (file)
--- a/gdb/tilegx-tdep.c
+++ b/gdb/tilegx-tdep.c
@@ -219,7 +219,7 @@ tilegx_extract_return_value (struct type *type, struct regcache *regcache,
   int i, regnum = TILEGX_R0_REGNUM;
 
   for (i = 0; i < len; i += tilegx_reg_size)
-    regcache_raw_read (regcache, regnum++, valbuf + i);
+    regcache->raw_read (regnum++, valbuf + i);
 }
 
 /* Copy the function return value from VALBUF into the proper

diff --git a/gdb/v850-tdep.c b/gdb/v850-tdep.c
index ac7d6aa4240fccf3eed7e4ed5723222b5274917a..a8bc599f906f4e46e9f6d854ee93754f8ae2436a 100644 (file)
--- a/gdb/v850-tdep.c
+++ b/gdb/v850-tdep.c
@@ -1128,7 +1128,7 @@ v850_extract_return_value (struct type *type, struct regcache *regcache,
       gdb_byte buf[v850_reg_size];
       for (i = 0; len > 0; i += 4, len -= 4)
        {
-         regcache_raw_read (regcache, regnum++, buf);
+         regcache->raw_read (regnum++, buf);
          memcpy (valbuf + i, buf, len > 4 ? 4 : len);
        }
     }

diff --git a/gdb/xstormy16-tdep.c b/gdb/xstormy16-tdep.c
index 31650ac3a959c782e92202626374362ad107f4dc..805c7f2686e44b7912da1a7a3ee3207009f209b1 100644 (file)
--- a/gdb/xstormy16-tdep.c
+++ b/gdb/xstormy16-tdep.c
@@ -163,7 +163,7 @@ xstormy16_extract_return_value (struct type *type, struct regcache *regcache,
   int i, regnum = E_1ST_ARG_REGNUM;
 
   for (i = 0; i < len; i += xstormy16_reg_size)
-    regcache_raw_read (regcache, regnum++, valbuf + i);
+    regcache->raw_read (regnum++, valbuf + i);
 }
 
 /* Function: xstormy16_store_return_value

diff --git a/gdb/xtensa-tdep.c b/gdb/xtensa-tdep.c
index 01f96165dc8d89a03cf6318ce5a46e853635a819..32533e8c5fbad5f75a88f19b3a21938c3b471832 100644 (file)
--- a/gdb/xtensa-tdep.c
+++ b/gdb/xtensa-tdep.c
@@ -1598,7 +1598,7 @@ xtensa_extract_return_value (struct type *type,
       if (len < 4)
        regcache_raw_read_part (regcache, areg, offset, len, valbuf);
       else
-       regcache_raw_read (regcache, areg, valbuf);
+       regcache->raw_read (areg, valbuf);
     }
 }
 
@@ -1928,7 +1928,7 @@ xtensa_push_dummy_call (struct gdbarch *gdbarch,
         to modify WINDOWSTART register to make it look like there
         is only one register window corresponding to WINDOWEBASE.  */
 
-      regcache_raw_read (regcache, gdbarch_tdep (gdbarch)->wb_regnum, buf);
+      regcache->raw_read (gdbarch_tdep (gdbarch)->wb_regnum, buf);
       regcache_cooked_write_unsigned
        (regcache, gdbarch_tdep (gdbarch)->ws_regnum,
         1 << extract_unsigned_integer (buf, 4, byte_order));