diff options
36 files changed, 246 insertions, 310 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index d0cc45abad3..2d1dfb6045f 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,5 +1,11 @@ 2018-05-30 Simon Marchi <simon.marchi@ericsson.com> + * regcache.h (regcache_cooked_write): Remove, update callers to + use regcache::cooked_write. + * regcache.c (regcache_cooked_write): Remove. + +2018-05-30 Simon Marchi <simon.marchi@ericsson.com> + * regcache.h (regcache_invalidate): Remove, update callers to use detached_regcache::invalidate instead. * regcache.c (regcache_invalidate): Remove. diff --git a/gdb/aarch64-tdep.c b/gdb/aarch64-tdep.c index 6f4878a1c4e..ef9b71c668f 100644 --- a/gdb/aarch64-tdep.c +++ b/gdb/aarch64-tdep.c @@ -1271,7 +1271,7 @@ pass_in_v (struct gdbarch *gdbarch, /* PCS C.1, the argument is allocated to the least significant bits of V register. */ memcpy (reg, buf, len); - regcache_cooked_write (regcache, regnum, reg); + regcache->cooked_write (regnum, reg); if (aarch64_debug) { @@ -1931,7 +1931,7 @@ aarch64_store_return_value (struct type *type, struct regcache *regs, int len = TYPE_LENGTH (type); memcpy (buf, valbuf, len > V_REGISTER_SIZE ? V_REGISTER_SIZE : len); - regcache_cooked_write (regs, AARCH64_V0_REGNUM, buf); + regs->cooked_write (AARCH64_V0_REGNUM, buf); } else if (TYPE_CODE (type) == TYPE_CODE_INT || TYPE_CODE (type) == TYPE_CODE_CHAR @@ -1948,7 +1948,7 @@ aarch64_store_return_value (struct type *type, struct regcache *regs, LONGEST val = unpack_long (type, valbuf); store_signed_integer (tmpbuf, X_REGISTER_SIZE, byte_order, val); - regcache_cooked_write (regs, AARCH64_X0_REGNUM, tmpbuf); + regs->cooked_write (AARCH64_X0_REGNUM, tmpbuf); } else { @@ -1960,7 +1960,7 @@ aarch64_store_return_value (struct type *type, struct regcache *regs, while (len > 0) { - regcache_cooked_write (regs, regno++, valbuf); + regs->cooked_write (regno++, valbuf); len -= X_REGISTER_SIZE; valbuf += X_REGISTER_SIZE; } @@ -1986,7 +1986,7 @@ aarch64_store_return_value (struct type *type, struct regcache *regs, } memcpy (tmpbuf, valbuf, len); - regcache_cooked_write (regs, regno, tmpbuf); + regs->cooked_write (regno, tmpbuf); valbuf += len; } } @@ -1997,7 +1997,7 @@ aarch64_store_return_value (struct type *type, struct regcache *regs, gdb_byte buf[V_REGISTER_SIZE]; memcpy (buf, valbuf, TYPE_LENGTH (type)); - regcache_cooked_write (regs, AARCH64_V0_REGNUM, buf); + regs->cooked_write (AARCH64_V0_REGNUM, buf); } else { @@ -2012,7 +2012,7 @@ aarch64_store_return_value (struct type *type, struct regcache *regs, { memcpy (tmpbuf, valbuf, len > X_REGISTER_SIZE ? X_REGISTER_SIZE : len); - regcache_cooked_write (regs, regno++, tmpbuf); + regs->cooked_write (regno++, tmpbuf); len -= X_REGISTER_SIZE; valbuf += X_REGISTER_SIZE; } diff --git a/gdb/alpha-tdep.c b/gdb/alpha-tdep.c index d55f3c6a5d2..408bedc68db 100644 --- a/gdb/alpha-tdep.c +++ b/gdb/alpha-tdep.c @@ -453,10 +453,10 @@ alpha_push_dummy_call (struct gdbarch *gdbarch, struct value *function, /* Load the argument registers. */ for (i = 0; i < required_arg_regs; i++) { - regcache_cooked_write (regcache, ALPHA_A0_REGNUM + i, - arg_reg_buffer + i*ALPHA_REGISTER_SIZE); - regcache_cooked_write (regcache, ALPHA_FPA0_REGNUM + i, - arg_reg_buffer + i*ALPHA_REGISTER_SIZE); + regcache->cooked_write (ALPHA_A0_REGNUM + i, + arg_reg_buffer + i * ALPHA_REGISTER_SIZE); + regcache->cooked_write (ALPHA_FPA0_REGNUM + i, + arg_reg_buffer + i * ALPHA_REGISTER_SIZE); } /* Finally, update the stack pointer. */ @@ -552,11 +552,11 @@ alpha_store_return_value (struct type *valtype, struct regcache *regcache, { case 4: alpha_lds (gdbarch, raw_buffer, valbuf); - regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, raw_buffer); + regcache->cooked_write (ALPHA_FP0_REGNUM, raw_buffer); break; case 8: - regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, valbuf); + regcache->cooked_write (ALPHA_FP0_REGNUM, valbuf); break; case 16: @@ -576,12 +576,12 @@ alpha_store_return_value (struct type *valtype, struct regcache *regcache, { case 8: /* ??? This isn't correct wrt the ABI, but it's what GCC does. */ - regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, valbuf); + regcache->cooked_write (ALPHA_FP0_REGNUM, valbuf); break; case 16: - regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, valbuf); - regcache_cooked_write (regcache, ALPHA_FP0_REGNUM + 1, valbuf + 8); + regcache->cooked_write (ALPHA_FP0_REGNUM, valbuf); + regcache->cooked_write (ALPHA_FP0_REGNUM + 1, valbuf + 8); break; case 32: diff --git a/gdb/amd64-tdep.c b/gdb/amd64-tdep.c index 9a1e68ecb17..975c907527f 100644 --- a/gdb/amd64-tdep.c +++ b/gdb/amd64-tdep.c @@ -1010,7 +1010,7 @@ amd64_push_dummy_call (struct gdbarch *gdbarch, struct value *function, if (struct_return) { store_unsigned_integer (buf, 8, byte_order, struct_addr); - regcache_cooked_write (regcache, AMD64_RDI_REGNUM, buf); + regcache->cooked_write (AMD64_RDI_REGNUM, buf); } /* Store return address. */ @@ -1020,10 +1020,10 @@ amd64_push_dummy_call (struct gdbarch *gdbarch, struct value *function, /* Finally, update the stack pointer... */ store_unsigned_integer (buf, 8, byte_order, sp); - regcache_cooked_write (regcache, AMD64_RSP_REGNUM, buf); + regcache->cooked_write (AMD64_RSP_REGNUM, buf); /* ...and fake a frame pointer. */ - regcache_cooked_write (regcache, AMD64_RBP_REGNUM, buf); + regcache->cooked_write (AMD64_RBP_REGNUM, buf); return sp + 16; } diff --git a/gdb/amd64-windows-tdep.c b/gdb/amd64-windows-tdep.c index 7e0c086a1e5..83a7f2f32ed 100644 --- a/gdb/amd64-windows-tdep.c +++ b/gdb/amd64-windows-tdep.c @@ -145,7 +145,7 @@ amd64_windows_store_arg_in_reg (struct regcache *regcache, gdb_assert (TYPE_LENGTH (type) <= 8); memset (buf, 0, sizeof buf); memcpy (buf, valbuf, std::min (TYPE_LENGTH (type), (unsigned int) 8)); - regcache_cooked_write (regcache, regno, buf); + regcache->cooked_write (regno, buf); } /* Push the arguments for an inferior function call, and return @@ -262,7 +262,7 @@ amd64_windows_push_dummy_call const int arg_regnum = amd64_windows_dummy_call_integer_regs[0]; store_unsigned_integer (buf, 8, byte_order, struct_addr); - regcache_cooked_write (regcache, arg_regnum, buf); + regcache->cooked_write (arg_regnum, buf); } /* Reserve some memory on the stack for the integer-parameter @@ -276,10 +276,10 @@ amd64_windows_push_dummy_call /* Update the stack pointer... */ store_unsigned_integer (buf, 8, byte_order, sp); - regcache_cooked_write (regcache, AMD64_RSP_REGNUM, buf); + regcache->cooked_write (AMD64_RSP_REGNUM, buf); /* ...and fake a frame pointer. */ - regcache_cooked_write (regcache, AMD64_RBP_REGNUM, buf); + regcache->cooked_write (AMD64_RBP_REGNUM, buf); return sp + 16; } diff --git a/gdb/arc-tdep.c b/gdb/arc-tdep.c index 286a289a06c..fad91709786 100644 --- a/gdb/arc-tdep.c +++ b/gdb/arc-tdep.c @@ -664,7 +664,7 @@ arc_push_dummy_call (struct gdbarch *gdbarch, struct value *function, /* Note we don't use write_unsigned here, since that would convert the byte order, but we are already in the correct byte order. */ - regcache_cooked_write (regcache, arg_reg, data); + regcache->cooked_write (arg_reg, data); data += ARC_REGISTER_SIZE; total_space -= ARC_REGISTER_SIZE; diff --git a/gdb/arm-tdep.c b/gdb/arm-tdep.c index abb1a88bfac..3ea0e79b739 100644 --- a/gdb/arm-tdep.c +++ b/gdb/arm-tdep.c @@ -3804,8 +3804,7 @@ arm_push_dummy_call (struct gdbarch *gdbarch, struct value *function, reg_char, reg_scaled + i); regnum = user_reg_map_name_to_regnum (gdbarch, name_buf, strlen (name_buf)); - regcache_cooked_write (regcache, regnum, - val + i * unit_length); + regcache->cooked_write (regnum, val + i * unit_length); } } continue; @@ -8099,7 +8098,7 @@ arm_store_return_value (struct type *type, struct regcache *regs, case ARM_FLOAT_FPA: target_float_convert (valbuf, type, buf, arm_ext_type (gdbarch)); - regcache_cooked_write (regs, ARM_F0_REGNUM, buf); + regs->cooked_write (ARM_F0_REGNUM, buf); break; case ARM_FLOAT_SOFT_FPA: @@ -8107,10 +8106,9 @@ arm_store_return_value (struct type *type, struct regcache *regs, /* ARM_FLOAT_VFP can arise if this is a variadic function so not using the VFP ABI code. */ case ARM_FLOAT_VFP: - regcache_cooked_write (regs, ARM_A1_REGNUM, valbuf); + regs->cooked_write (ARM_A1_REGNUM, valbuf); if (TYPE_LENGTH (type) > 4) - regcache_cooked_write (regs, ARM_A1_REGNUM + 1, - valbuf + INT_REGISTER_SIZE); + regs->cooked_write (ARM_A1_REGNUM + 1, valbuf + INT_REGISTER_SIZE); break; default: @@ -8135,7 +8133,7 @@ arm_store_return_value (struct type *type, struct regcache *regs, LONGEST val = unpack_long (type, valbuf); store_signed_integer (tmpbuf, INT_REGISTER_SIZE, byte_order, val); - regcache_cooked_write (regs, ARM_A1_REGNUM, tmpbuf); + regs->cooked_write (ARM_A1_REGNUM, tmpbuf); } else { @@ -8147,7 +8145,7 @@ arm_store_return_value (struct type *type, struct regcache *regs, while (len > 0) { - regcache_cooked_write (regs, regno++, valbuf); + regs->cooked_write (regno++, valbuf); len -= INT_REGISTER_SIZE; valbuf += INT_REGISTER_SIZE; } @@ -8166,7 +8164,7 @@ arm_store_return_value (struct type *type, struct regcache *regs, { memcpy (tmpbuf, valbuf, len > INT_REGISTER_SIZE ? INT_REGISTER_SIZE : len); - regcache_cooked_write (regs, regno++, tmpbuf); + regs->cooked_write (regno++, tmpbuf); len -= INT_REGISTER_SIZE; valbuf += INT_REGISTER_SIZE; } @@ -8213,8 +8211,7 @@ arm_return_value (struct gdbarch *gdbarch, struct value *function, regnum = user_reg_map_name_to_regnum (gdbarch, name_buf, strlen (name_buf)); if (writebuf) - regcache_cooked_write (regcache, regnum, - writebuf + i * unit_length); + regcache->cooked_write (regnum, writebuf + i * unit_length); if (readbuf) regcache->cooked_read (regnum, readbuf + i * unit_length); } diff --git a/gdb/avr-tdep.c b/gdb/avr-tdep.c index 2629d54d457..d7895afac38 100644 --- a/gdb/avr-tdep.c +++ b/gdb/avr-tdep.c @@ -953,7 +953,7 @@ avr_return_value (struct gdbarch *gdbarch, struct value *function, if (writebuf != NULL) { for (i = 0; i < TYPE_LENGTH (valtype); i++) - regcache_cooked_write (regcache, lsb_reg + i, writebuf + i); + regcache->cooked_write (lsb_reg + i, writebuf + i); } if (readbuf != NULL) diff --git a/gdb/bfin-tdep.c b/gdb/bfin-tdep.c index a2b3464b347..da62130231b 100644 --- a/gdb/bfin-tdep.c +++ b/gdb/bfin-tdep.c @@ -647,7 +647,7 @@ bfin_store_return_value (struct type *type, while (len > 0) { - regcache_cooked_write (regs, regno++, valbuf); + regs->cooked_write (regno++, valbuf); len -= 4; valbuf += 4; } diff --git a/gdb/cris-tdep.c b/gdb/cris-tdep.c index 5fa79ef2cfa..a0fb3b27ec3 100644 --- a/gdb/cris-tdep.c +++ b/gdb/cris-tdep.c @@ -849,7 +849,7 @@ cris_push_dummy_call (struct gdbarch *gdbarch, struct value *function, /* Data passed by value. Fits in available register(s). */ for (i = 0; i < reg_demand; i++) { - regcache_cooked_write (regcache, argreg, val); + regcache->cooked_write (argreg, val); argreg++; val += 4; } @@ -862,7 +862,7 @@ cris_push_dummy_call (struct gdbarch *gdbarch, struct value *function, { if (argreg <= ARG4_REGNUM) { - regcache_cooked_write (regcache, argreg, val); + regcache->cooked_write (argreg, val); argreg++; val += 4; } diff --git a/gdb/frame.c b/gdb/frame.c index c0f6e64dfc2..89f48aea696 100644 --- a/gdb/frame.c +++ b/gdb/frame.c @@ -1365,7 +1365,7 @@ put_frame_register (struct frame_info *frame, int regnum, break; } case lval_register: - regcache_cooked_write (get_current_regcache (), realnum, buf); + get_current_regcache ()->cooked_write (realnum, buf); break; default: error (_("Attempt to assign to an unmodifiable value.")); diff --git a/gdb/frv-tdep.c b/gdb/frv-tdep.c index 7adffc479bb..1eed441f2b3 100644 --- a/gdb/frv-tdep.c +++ b/gdb/frv-tdep.c @@ -1327,12 +1327,12 @@ frv_store_return_value (struct type *type, struct regcache *regcache, bfd_byte val[4]; memset (val, 0, sizeof (val)); memcpy (val + (4 - len), valbuf, len); - regcache_cooked_write (regcache, 8, val); + regcache->cooked_write (8, val); } else if (len == 8) { - regcache_cooked_write (regcache, 8, valbuf); - regcache_cooked_write (regcache, 9, (bfd_byte *) valbuf + 4); + regcache->cooked_write (8, valbuf); + regcache->cooked_write (9, (bfd_byte *) valbuf + 4); } else internal_error (__FILE__, __LINE__, diff --git a/gdb/hppa-tdep.c b/gdb/hppa-tdep.c index 5fe7851afeb..1f3581e5aa3 100644 --- a/gdb/hppa-tdep.c +++ b/gdb/hppa-tdep.c @@ -820,17 +820,15 @@ hppa32_push_dummy_call (struct gdbarch *gdbarch, struct value *function, int fpLreg = 72 + (param_ptr - 36) / 4 * 2; int fpreg = 74 + (param_ptr - 32) / 8 * 4; - regcache_cooked_write (regcache, grreg, param_val); - regcache_cooked_write (regcache, fpLreg, param_val); + regcache->cooked_write (grreg, param_val); + regcache->cooked_write (fpLreg, param_val); if (param_len > 4) { - regcache_cooked_write (regcache, grreg + 1, - param_val + 4); + regcache->cooked_write (grreg + 1, param_val + 4); - regcache_cooked_write (regcache, fpreg, param_val); - regcache_cooked_write (regcache, fpreg + 1, - param_val + 4); + regcache->cooked_write (fpreg, param_val); + regcache->cooked_write (fpreg + 1, param_val + 4); } } } @@ -1167,7 +1165,7 @@ hppa32_return_value (struct gdbarch *gdbarch, struct value *function, if (readbuf != NULL) regcache->cooked_read (reg, readbuf + b); if (writebuf != NULL) - regcache_cooked_write (regcache, reg, writebuf + b); + regcache->cooked_write (reg, writebuf + b); reg++; } return RETURN_VALUE_REGISTER_CONVENTION; diff --git a/gdb/i386-darwin-tdep.c b/gdb/i386-darwin-tdep.c index 21f0a4c6083..5a1807ae4d6 100644 --- a/gdb/i386-darwin-tdep.c +++ b/gdb/i386-darwin-tdep.c @@ -227,10 +227,10 @@ i386_darwin_push_dummy_call (struct gdbarch *gdbarch, struct value *function, /* Finally, update the stack pointer... */ store_unsigned_integer (buf, 4, byte_order, sp); - regcache_cooked_write (regcache, I386_ESP_REGNUM, buf); + regcache->cooked_write (I386_ESP_REGNUM, buf); /* ...and fake a frame pointer. */ - regcache_cooked_write (regcache, I386_EBP_REGNUM, buf); + regcache->cooked_write (I386_EBP_REGNUM, buf); /* MarkK wrote: This "+ 8" is all over the place: (i386_frame_this_id, i386_sigtramp_frame_this_id, diff --git a/gdb/i386-tdep.c b/gdb/i386-tdep.c index cdb5fc8f59b..158344f2309 100644 --- a/gdb/i386-tdep.c +++ b/gdb/i386-tdep.c @@ -2755,10 +2755,10 @@ i386_push_dummy_call (struct gdbarch *gdbarch, struct value *function, /* Finally, update the stack pointer... */ store_unsigned_integer (buf, 4, byte_order, sp); - regcache_cooked_write (regcache, I386_ESP_REGNUM, buf); + regcache->cooked_write (I386_ESP_REGNUM, buf); /* ...and fake a frame pointer. */ - regcache_cooked_write (regcache, I386_EBP_REGNUM, buf); + regcache->cooked_write (I386_EBP_REGNUM, buf); /* MarkK wrote: This "+ 8" is all over the place: (i386_frame_this_id, i386_sigtramp_frame_this_id, diff --git a/gdb/ia64-tdep.c b/gdb/ia64-tdep.c index 7eb84ff02b2..a24e5cbda6c 100644 --- a/gdb/ia64-tdep.c +++ b/gdb/ia64-tdep.c @@ -3277,7 +3277,7 @@ ia64_store_return_value (struct type *type, struct regcache *regcache, { target_float_convert (valbuf + offset, float_elt_type, to, ia64_ext_type (gdbarch)); - regcache_cooked_write (regcache, regnum, to); + regcache->cooked_write (regnum, to); offset += TYPE_LENGTH (float_elt_type); regnum++; } @@ -3834,7 +3834,7 @@ ia64_push_dummy_call (struct gdbarch *gdbarch, struct value *function, target_float_convert (value_contents (arg) + argoffset, float_elt_type, to, ia64_ext_type (gdbarch)); - regcache_cooked_write (regcache, floatreg, to); + regcache->cooked_write (floatreg, to); floatreg++; argoffset += TYPE_LENGTH (float_elt_type); len -= TYPE_LENGTH (float_elt_type); diff --git a/gdb/m32c-tdep.c b/gdb/m32c-tdep.c index 2825efbb9cc..b7cba1c3770 100644 --- a/gdb/m32c-tdep.c +++ b/gdb/m32c-tdep.c @@ -511,13 +511,13 @@ m32c_cat_write (struct m32c_reg *reg, struct regcache *cache, if (gdbarch_byte_order (reg->arch) == BFD_ENDIAN_BIG) { - regcache_cooked_write (cache, reg->rx->num, buf); - regcache_cooked_write (cache, reg->ry->num, buf + high_bytes); + cache->cooked_write (reg->rx->num, buf); + cache->cooked_write (reg->ry->num, buf + high_bytes); } else { - regcache_cooked_write (cache, reg->rx->num, buf + low_bytes); - regcache_cooked_write (cache, reg->ry->num, buf); + cache->cooked_write (reg->rx->num, buf + low_bytes); + cache->cooked_write (reg->ry->num, buf); } return REG_VALID; @@ -571,17 +571,17 @@ m32c_r3r2r1r0_write (struct m32c_reg *reg, struct regcache *cache, if (gdbarch_byte_order (reg->arch) == BFD_ENDIAN_BIG) { - regcache_cooked_write (cache, tdep->r0->num, buf + len * 3); - regcache_cooked_write (cache, tdep->r1->num, buf + len * 2); - regcache_cooked_write (cache, tdep->r2->num, buf + len * 1); - regcache_cooked_write (cache, tdep->r3->num, buf); + cache->cooked_write (tdep->r0->num, buf + len * 3); + cache->cooked_write (tdep->r1->num, buf + len * 2); + cache->cooked_write (tdep->r2->num, buf + len * 1); + cache->cooked_write (tdep->r3->num, buf); } else { - regcache_cooked_write (cache, tdep->r0->num, buf); - regcache_cooked_write (cache, tdep->r1->num, buf + len * 1); - regcache_cooked_write (cache, tdep->r2->num, buf + len * 2); - regcache_cooked_write (cache, tdep->r3->num, buf + len * 3); + cache->cooked_write (tdep->r0->num, buf); + cache->cooked_write (tdep->r1->num, buf + len * 1); + cache->cooked_write (tdep->r2->num, buf + len * 2); + cache->cooked_write (tdep->r3->num, buf + len * 3); } return REG_VALID; @@ -2092,7 +2092,7 @@ m32c_push_dummy_call (struct gdbarch *gdbarch, struct value *function, && arg_size == 2 && i < num_prototyped_args && m32c_reg_arg_type (arg_type)) - regcache_cooked_write (regcache, tdep->r2->num, arg_bits); + regcache->cooked_write (tdep->r2->num, arg_bits); /* Everything else goes on the stack. */ else diff --git a/gdb/m68k-tdep.c b/gdb/m68k-tdep.c index 432c37cbdec..a6e9b58a7d1 100644 --- a/gdb/m68k-tdep.c +++ b/gdb/m68k-tdep.c @@ -525,7 +525,7 @@ m68k_push_dummy_call (struct gdbarch *gdbarch, struct value *function, if (struct_return) { store_unsigned_integer (buf, 4, byte_order, struct_addr); - regcache_cooked_write (regcache, tdep->struct_value_regnum, buf); + regcache->cooked_write (tdep->struct_value_regnum, buf); } /* Store return address. */ @@ -535,10 +535,10 @@ m68k_push_dummy_call (struct gdbarch *gdbarch, struct value *function, /* Finally, update the stack pointer... */ store_unsigned_integer (buf, 4, byte_order, sp); - regcache_cooked_write (regcache, M68K_SP_REGNUM, buf); + regcache->cooked_write (M68K_SP_REGNUM, buf); /* ...and fake a frame pointer. */ - regcache_cooked_write (regcache, M68K_FP_REGNUM, buf); + regcache->cooked_write (M68K_FP_REGNUM, buf); /* DWARF2/GCC uses the stack address *before* the function call as a frame's CFA. */ diff --git a/gdb/microblaze-tdep.c b/gdb/microblaze-tdep.c index f5035904aec..9bac8643c4a 100644 --- a/gdb/microblaze-tdep.c +++ b/gdb/microblaze-tdep.c @@ -573,13 +573,13 @@ microblaze_store_return_value (struct type *type, struct regcache *regcache, { gdb_assert (len == 8); memcpy (buf, valbuf, 8); - regcache_cooked_write (regcache, MICROBLAZE_RETVAL_REGNUM+1, buf + 4); + regcache->cooked_write (MICROBLAZE_RETVAL_REGNUM+1, buf + 4); } else /* ??? Do we need to do any sign-extension here? */ memcpy (buf + 4 - len, valbuf, len); - regcache_cooked_write (regcache, MICROBLAZE_RETVAL_REGNUM, buf); + regcache->cooked_write (MICROBLAZE_RETVAL_REGNUM, buf); } static enum return_value_convention diff --git a/gdb/nds32-tdep.c b/gdb/nds32-tdep.c index 35375fb1eeb..b616cc9b2ce 100644 --- a/gdb/nds32-tdep.c +++ b/gdb/nds32-tdep.c @@ -1587,13 +1587,11 @@ nds32_push_dummy_call (struct gdbarch *gdbarch, struct value *function, switch (len) { case 4: - regcache_cooked_write (regcache, - tdep->fs0_regnum + foff, val); + regcache->cooked_write (tdep->fs0_regnum + foff, val); foff++; break; case 8: - regcache_cooked_write (regcache, - NDS32_FD0_REGNUM + (foff >> 1), val); + regcache->cooked_write (NDS32_FD0_REGNUM + (foff >> 1), val); foff += 2; break; default: @@ -1830,9 +1828,9 @@ nds32_store_return_value (struct gdbarch *gdbarch, struct type *type, if (abi_use_fpr && calling_use_fpr) { if (len == 4) - regcache_cooked_write (regcache, tdep->fs0_regnum, valbuf); + regcache->cooked_write (tdep->fs0_regnum, valbuf); else if (len == 8) - regcache_cooked_write (regcache, NDS32_FD0_REGNUM, valbuf); + regcache->cooked_write (NDS32_FD0_REGNUM, valbuf); else internal_error (__FILE__, __LINE__, _("Cannot store return value of %d bytes " @@ -1849,7 +1847,7 @@ nds32_store_return_value (struct gdbarch *gdbarch, struct type *type, } else if (len == 4) { - regcache_cooked_write (regcache, NDS32_R0_REGNUM, valbuf); + regcache->cooked_write (NDS32_R0_REGNUM, valbuf); } else if (len < 8) { @@ -1867,8 +1865,8 @@ nds32_store_return_value (struct gdbarch *gdbarch, struct type *type, } else { - regcache_cooked_write (regcache, NDS32_R0_REGNUM, valbuf); - regcache_cooked_write (regcache, NDS32_R0_REGNUM + 1, valbuf + 4); + regcache->cooked_write (NDS32_R0_REGNUM, valbuf); + regcache->cooked_write (NDS32_R0_REGNUM + 1, valbuf + 4); } } } diff --git a/gdb/nios2-tdep.c b/gdb/nios2-tdep.c index e1cbd976330..91b4381f0b7 100644 --- a/gdb/nios2-tdep.c +++ b/gdb/nios2-tdep.c @@ -228,13 +228,13 @@ nios2_store_return_value (struct gdbarch *gdbarch, struct type *valtype, /* Return values of up to 8 bytes are returned in $r2 $r3. */ if (len <= register_size (gdbarch, NIOS2_R2_REGNUM)) - regcache_cooked_write (regcache, NIOS2_R2_REGNUM, valbuf); + regcache->cooked_write (NIOS2_R2_REGNUM, valbuf); else { gdb_assert (len <= (register_size (gdbarch, NIOS2_R2_REGNUM) + register_size (gdbarch, NIOS2_R3_REGNUM))); - regcache_cooked_write (regcache, NIOS2_R2_REGNUM, valbuf); - regcache_cooked_write (regcache, NIOS2_R3_REGNUM, valbuf + 4); + regcache->cooked_write (NIOS2_R2_REGNUM, valbuf); + regcache->cooked_write (NIOS2_R3_REGNUM, valbuf + 4); } } diff --git a/gdb/or1k-tdep.c b/gdb/or1k-tdep.c index 329615f2d39..c5104e3959d 100644 --- a/gdb/or1k-tdep.c +++ b/gdb/or1k-tdep.c @@ -297,7 +297,7 @@ or1k_return_value (struct gdbarch *gdbarch, struct value *functype, else memcpy (buf, writebuf, rv_size); - regcache_cooked_write (regcache, OR1K_RV_REGNUM, buf); + regcache->cooked_write (OR1K_RV_REGNUM, buf); free (buf); } @@ -330,8 +330,8 @@ or1k_return_value (struct gdbarch *gdbarch, struct value *functype, memcpy (buf_hi, writebuf, rv_size - bpw); memcpy (buf_lo, writebuf + bpw, bpw); - regcache_cooked_write (regcache, OR1K_RV_REGNUM, buf_hi); - regcache_cooked_write (regcache, OR1K_RV_REGNUM + 1, buf_lo); + regcache->cooked_write (OR1K_RV_REGNUM, buf_hi); + regcache->cooked_write (OR1K_RV_REGNUM + 1, buf_lo); free (buf_lo); free (buf_hi); diff --git a/gdb/ppc-sysv-tdep.c b/gdb/ppc-sysv-tdep.c index 04f9447bad6..42dc63c9485 100644 --- a/gdb/ppc-sysv-tdep.c +++ b/gdb/ppc-sysv-tdep.c @@ -139,9 +139,8 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum + freg); target_float_convert (val, type, regval, regtype); - regcache_cooked_write (regcache, - tdep->ppc_fp0_regnum + freg, - regval); + regcache->cooked_write (tdep->ppc_fp0_regnum + freg, + regval); } freg++; } @@ -176,12 +175,9 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, { if (write_pass) { - regcache_cooked_write (regcache, - tdep->ppc_fp0_regnum + freg, - val); - regcache_cooked_write (regcache, - tdep->ppc_fp0_regnum + freg + 1, - val + 8); + regcache->cooked_write (tdep->ppc_fp0_regnum + freg, val); + regcache->cooked_write (tdep->ppc_fp0_regnum + freg + 1, + val + 8); } freg += 2; } @@ -221,12 +217,10 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, greg++; if (write_pass) { - regcache_cooked_write (regcache, - tdep->ppc_gp0_regnum + greg + 0, - val + 0); - regcache_cooked_write (regcache, - tdep->ppc_gp0_regnum + greg + 1, - val + 4); + regcache->cooked_write (tdep->ppc_gp0_regnum + greg + 0, + val + 0); + regcache->cooked_write (tdep->ppc_gp0_regnum + greg + 1, + val + 4); } greg += 2; } @@ -253,18 +247,14 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, { if (write_pass) { - regcache_cooked_write (regcache, - tdep->ppc_gp0_regnum + greg + 0, - val + 0); - regcache_cooked_write (regcache, - tdep->ppc_gp0_regnum + greg + 1, - val + 4); - regcache_cooked_write (regcache, - tdep->ppc_gp0_regnum + greg + 2, - val + 8); - regcache_cooked_write (regcache, - tdep->ppc_gp0_regnum + greg + 3, - val + 12); + regcache->cooked_write (tdep->ppc_gp0_regnum + greg + 0, + val + 0); + regcache->cooked_write (tdep->ppc_gp0_regnum + greg + 1, + val + 4); + regcache->cooked_write (tdep->ppc_gp0_regnum + greg + 2, + val + 8); + regcache->cooked_write (tdep->ppc_gp0_regnum + greg + 3, + val + 12); } greg += 4; } @@ -292,8 +282,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, else p = val; - regcache_cooked_write (regcache, - tdep->ppc_fp0_regnum + freg, p); + regcache->cooked_write (tdep->ppc_fp0_regnum + freg, p); } freg++; @@ -322,10 +311,9 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, if (write_pass) { - regcache_cooked_write (regcache, - tdep->ppc_fp0_regnum + freg, val); - regcache_cooked_write (regcache, - tdep->ppc_fp0_regnum + freg + 1, val + 8); + regcache->cooked_write (tdep->ppc_fp0_regnum + freg, val); + regcache->cooked_write (tdep->ppc_fp0_regnum + freg + 1, + val + 8); } } else @@ -370,7 +358,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, = register_type (gdbarch, regnum); target_float_convert (elval, eltype, regval, regtype); - regcache_cooked_write (regcache, regnum, regval); + regcache->cooked_write (regnum, regval); } freg++; } @@ -402,10 +390,8 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, if (write_pass) { int regnum = tdep->ppc_gp0_regnum + greg; - regcache_cooked_write (regcache, - regnum + 0, elval + 0); - regcache_cooked_write (regcache, - regnum + 1, elval + 4); + regcache->cooked_write (regnum + 0, elval + 0); + regcache->cooked_write (regnum + 1, elval + 4); } greg += 2; } @@ -419,9 +405,8 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, if (greg <= 10) { if (write_pass) - regcache_cooked_write (regcache, - tdep->ppc_gp0_regnum + greg, - word); + regcache->cooked_write (tdep->ppc_gp0_regnum + greg, + word); greg++; } else @@ -450,9 +435,8 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, if (vreg <= 13) { if (write_pass) - regcache_cooked_write (regcache, - tdep->ppc_vr0_regnum + vreg, - elval); + regcache->cooked_write (tdep->ppc_vr0_regnum + vreg, + elval); vreg++; } else @@ -474,8 +458,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, if (vreg <= 13) { if (write_pass) - regcache_cooked_write (regcache, - tdep->ppc_vr0_regnum + vreg, val); + regcache->cooked_write (tdep->ppc_vr0_regnum + vreg, val); vreg++; } else @@ -501,8 +484,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, if (greg <= 10) { if (write_pass) - regcache_cooked_write (regcache, - tdep->ppc_ev0_regnum + greg, val); + regcache->cooked_write (tdep->ppc_ev0_regnum + greg, val); greg++; } else @@ -552,8 +534,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, if (greg <= 10) { if (write_pass) - regcache_cooked_write (regcache, - tdep->ppc_gp0_regnum + greg, word); + regcache->cooked_write (tdep->ppc_gp0_regnum + greg, word); greg++; } else @@ -636,7 +617,7 @@ get_decimal_float_return_value (struct gdbarch *gdbarch, struct type *valtype, else p = writebuf; - regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, p); + regcache->cooked_write (tdep->ppc_fp0_regnum + 1, p); } if (readbuf != NULL) { @@ -657,8 +638,8 @@ get_decimal_float_return_value (struct gdbarch *gdbarch, struct type *valtype, for (i = 0; i < 2; i++) { if (writebuf != NULL) - regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 2 + i, - writebuf + i * 8); + regcache->cooked_write (tdep->ppc_fp0_regnum + 2 + i, + writebuf + i * 8); if (readbuf != NULL) regcache->cooked_read (tdep->ppc_fp0_regnum + 2 + i, readbuf + i * 8); @@ -720,7 +701,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type, gdb_byte regval[PPC_MAX_REGISTER_SIZE]; struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum); target_float_convert (writebuf, type, regval, regtype); - regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, regval); + regcache->cooked_write (tdep->ppc_fp0_regnum + 1, regval); } return RETURN_VALUE_REGISTER_CONVENTION; } @@ -738,9 +719,8 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type, } if (writebuf) { - regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, writebuf); - regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 2, - writebuf + 8); + regcache->cooked_write (tdep->ppc_fp0_regnum + 1, writebuf); + regcache->cooked_write (tdep->ppc_fp0_regnum + 2, writebuf + 8); } return RETURN_VALUE_REGISTER_CONVENTION; } @@ -761,13 +741,10 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type, } if (writebuf) { - regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, writebuf); - regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4, - writebuf + 4); - regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 5, - writebuf + 8); - regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 6, - writebuf + 12); + regcache->cooked_write (tdep->ppc_gp0_regnum + 3, writebuf); + regcache->cooked_write (tdep->ppc_gp0_regnum + 4, writebuf + 4); + regcache->cooked_write (tdep->ppc_gp0_regnum + 5, writebuf + 8); + regcache->cooked_write (tdep->ppc_gp0_regnum + 6, writebuf + 12); } return RETURN_VALUE_REGISTER_CONVENTION; } @@ -787,10 +764,8 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type, { /* A long long, double or _Decimal64 stored in the 32 bit r3/r4. */ - regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, - writebuf + 0); - regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4, - writebuf + 4); + regcache->cooked_write (tdep->ppc_gp0_regnum + 3, writebuf + 0); + regcache->cooked_write (tdep->ppc_gp0_regnum + 4, writebuf + 4); } return RETURN_VALUE_REGISTER_CONVENTION; } @@ -849,7 +824,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type, { target_float_convert (writebuf + offset, eltype, regval, regtype); - regcache_cooked_write (regcache, regnum, regval); + regcache->cooked_write (regnum, regval); } if (readbuf != NULL) { @@ -895,7 +870,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type, int regnum = tdep->ppc_vr0_regnum + 2 + i; if (writebuf != NULL) - regcache_cooked_write (regcache, regnum, writebuf + offset); + regcache->cooked_write (regnum, writebuf + offset); if (readbuf != NULL) regcache->cooked_read (regnum, readbuf + offset); } @@ -915,7 +890,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type, if (writebuf) { /* Altivec places the return value in "v2". */ - regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + 2, writebuf); + regcache->cooked_write (tdep->ppc_vr0_regnum + 2, writebuf); } return RETURN_VALUE_REGISTER_CONVENTION; } @@ -936,14 +911,10 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type, } if (writebuf) { - regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, - writebuf + 0); - regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4, - writebuf + 4); - regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 5, - writebuf + 8); - regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 6, - writebuf + 12); + regcache->cooked_write (tdep->ppc_gp0_regnum + 3, writebuf + 0); + regcache->cooked_write (tdep->ppc_gp0_regnum + 4, writebuf + 4); + regcache->cooked_write (tdep->ppc_gp0_regnum + 5, writebuf + 8); + regcache->cooked_write (tdep->ppc_gp0_regnum + 6, writebuf + 12); } return RETURN_VALUE_REGISTER_CONVENTION; } @@ -960,7 +931,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type, if (readbuf) regcache->cooked_read (tdep->ppc_ev0_regnum + 3, readbuf); if (writebuf) - regcache_cooked_write (regcache, tdep->ppc_ev0_regnum + 3, writebuf); + regcache->cooked_write (tdep->ppc_ev0_regnum + 3, writebuf); return RETURN_VALUE_REGISTER_CONVENTION; } if (broken_gcc && TYPE_LENGTH (type) <= 8) @@ -985,11 +956,11 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type, { memset (regvals, 0, sizeof regvals); memcpy (regvals + offset, writebuf, len); - regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, - regvals + 0 * tdep->wordsize); + regcache->cooked_write (tdep->ppc_gp0_regnum + 3, + regvals + 0 * tdep->wordsize); if (len > tdep->wordsize) - regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4, - regvals + 1 * tdep->wordsize); + regcache->cooked_write (tdep->ppc_gp0_regnum + 4, + regvals + 1 * tdep->wordsize); } return RETURN_VALUE_REGISTER_CONVENTION; @@ -1017,11 +988,11 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type, gdb_byte regvals[PPC_MAX_REGISTER_SIZE * 2]; memset (regvals, 0, sizeof regvals); memcpy (regvals, writebuf, TYPE_LENGTH (type)); - regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, - regvals + 0 * tdep->wordsize); + regcache->cooked_write (tdep->ppc_gp0_regnum + 3, + regvals + 0 * tdep->wordsize); if (TYPE_LENGTH (type) > tdep->wordsize) - regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4, - regvals + 1 * tdep->wordsize); + regcache->cooked_write (tdep->ppc_gp0_regnum + 4, + regvals + 1 * tdep->wordsize); } return RETURN_VALUE_REGISTER_CONVENTION; } @@ -1305,8 +1276,8 @@ ppc64_sysv_abi_push_val (struct gdbarch *gdbarch, while (len >= tdep->wordsize) { if (argpos->regcache && argpos->greg <= 10) - regcache_cooked_write (argpos->regcache, - tdep->ppc_gp0_regnum + argpos->greg, val); + argpos->regcache->cooked_write (tdep->ppc_gp0_regnum + argpos->greg, + val); argpos->greg++; len -= tdep->wordsize; val += tdep->wordsize; @@ -1363,7 +1334,7 @@ ppc64_sysv_abi_push_freg (struct gdbarch *gdbarch, gdb_byte regval[PPC_MAX_REGISTER_SIZE]; target_float_convert (val, type, regval, regtype); - regcache_cooked_write (argpos->regcache, regnum, regval); + argpos->regcache->cooked_write (regnum, regval); } argpos->freg++; @@ -1397,9 +1368,9 @@ ppc64_sysv_abi_push_freg (struct gdbarch *gdbarch, { int regnum = tdep->ppc_fp0_regnum + argpos->freg; - regcache_cooked_write (argpos->regcache, regnum, val); + argpos->regcache->cooked_write (regnum, val); if (argpos->freg <= 12) - regcache_cooked_write (argpos->regcache, regnum + 1, val + 8); + argpos->regcache->cooked_write (regnum + 1, val + 8); } argpos->freg += 2; @@ -1417,8 +1388,8 @@ ppc64_sysv_abi_push_freg (struct gdbarch *gdbarch, int lopart = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ? 8 : 0; int hipart = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ? 0 : 8; - regcache_cooked_write (argpos->regcache, regnum, val + hipart); - regcache_cooked_write (argpos->regcache, regnum + 1, val + lopart); + argpos->regcache->cooked_write (regnum, val + hipart); + argpos->regcache->cooked_write (regnum + 1, val + lopart); } argpos->freg += 2; @@ -1435,8 +1406,7 @@ ppc64_sysv_abi_push_vreg (struct gdbarch *gdbarch, const bfd_byte *val, struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); if (argpos->regcache && argpos->vreg <= 13) - regcache_cooked_write (argpos->regcache, - tdep->ppc_vr0_regnum + argpos->vreg, val); + argpos->regcache->cooked_write (tdep->ppc_vr0_regnum + argpos->vreg, val); argpos->vreg++; } @@ -1810,7 +1780,7 @@ ppc64_sysv_abi_return_value_base (struct gdbarch *gdbarch, struct type *valtype, if (writebuf != NULL) { target_float_convert (writebuf, valtype, regval, regtype); - regcache_cooked_write (regcache, regnum, regval); + regcache->cooked_write (regnum, regval); } if (readbuf != NULL) { @@ -1850,8 +1820,8 @@ ppc64_sysv_abi_return_value_base (struct gdbarch *gdbarch, struct type *valtype, if (writebuf != NULL) { - regcache_cooked_write (regcache, regnum, writebuf); - regcache_cooked_write (regcache, regnum + 1, writebuf + 8); + regcache->cooked_write (regnum, writebuf); + regcache->cooked_write (regnum + 1, writebuf + 8); } if (readbuf != NULL) { @@ -1872,8 +1842,8 @@ ppc64_sysv_abi_return_value_base (struct gdbarch *gdbarch, struct type *valtype, if (writebuf != NULL) { - regcache_cooked_write (regcache, regnum, writebuf + hipart); - regcache_cooked_write (regcache, regnum + 1, writebuf + lopart); + regcache->cooked_write (regnum, writebuf + hipart); + regcache->cooked_write (regnum + 1, writebuf + lopart); } if (readbuf != NULL) { @@ -1891,7 +1861,7 @@ ppc64_sysv_abi_return_value_base (struct gdbarch *gdbarch, struct type *valtype, int regnum = tdep->ppc_vr0_regnum + 2 + index; if (writebuf != NULL) - regcache_cooked_write (regcache, regnum, writebuf); + regcache->cooked_write (regnum, writebuf); if (readbuf != NULL) regcache->cooked_read (regnum, readbuf); return 1; @@ -1996,7 +1966,7 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function, int regnum = tdep->ppc_gp0_regnum + 3; if (writebuf != NULL) - regcache_cooked_write (regcache, regnum, writebuf); + regcache->cooked_write (regnum, writebuf); if (readbuf != NULL) regcache->cooked_read (regnum, readbuf); return RETURN_VALUE_REGISTER_CONVENTION; @@ -2078,7 +2048,7 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function, memcpy (regval + tdep->wordsize - len, writebuf, len); else memcpy (regval, writebuf + offset, len); - regcache_cooked_write (regcache, regnum, regval); + regcache->cooked_write (regnum, regval); } if (readbuf != NULL) { diff --git a/gdb/record-full.c b/gdb/record-full.c index 8c0534e2291..bf65701fb78 100644 --- a/gdb/record-full.c +++ b/gdb/record-full.c @@ -834,8 +834,7 @@ record_full_exec_insn (struct regcache *regcache, entry->u.reg.num); regcache->cooked_read (entry->u.reg.num, reg.data ()); - regcache_cooked_write (regcache, entry->u.reg.num, - record_full_get_loc (entry)); + regcache->cooked_write (entry->u.reg.num, record_full_get_loc (entry)); memcpy (record_full_get_loc (entry), reg.data (), entry->u.reg.len); } break; diff --git a/gdb/regcache.c b/gdb/regcache.c index 4dce9789a2b..0e2d040631b 100644 --- a/gdb/regcache.c +++ b/gdb/regcache.c @@ -772,13 +772,6 @@ regcache::raw_write (int regnum, const gdb_byte *buf) } void -regcache_cooked_write (struct regcache *regcache, int regnum, - const gdb_byte *buf) -{ - regcache->cooked_write (regnum, buf); -} - -void regcache::cooked_write (int regnum, const gdb_byte *buf) { gdb_assert (regnum >= 0); diff --git a/gdb/regcache.h b/gdb/regcache.h index 64e4cd7f094..4be1ae13616 100644 --- a/gdb/regcache.h +++ b/gdb/regcache.h @@ -50,14 +50,6 @@ extern void regcache_raw_write_unsigned (struct regcache *regcache, extern LONGEST regcache_raw_get_signed (struct regcache *regcache, int regnum); -/* Transfer of pseudo-registers. The read variants return a register - status, as an indication of when a ``cooked'' register was - constructed from valid, invalid or unavailable ``raw'' - registers. */ - -void regcache_cooked_write (struct regcache *regcache, int rawnum, - const gdb_byte *buf); - /* Read register REGNUM from REGCACHE and return a new value. This will call mark_value_bytes_unavailable as appropriate. */ @@ -304,8 +296,6 @@ public: read-only register cache. */ void restore (readonly_detached_regcache *src); - void cooked_write (int regnum, const gdb_byte *buf); - /* Update the value of raw register REGNUM (in the range [0..NUM_REGS)) and transfer its value to core-gdb. */ @@ -314,6 +304,9 @@ public: template<typename T, typename = RequireLongest<T>> void raw_write (int regnum, T val); + /* Transfer of pseudo-registers. */ + void cooked_write (int regnum, const gdb_byte *buf); + template<typename T, typename = RequireLongest<T>> void cooked_write (int regnum, T val); diff --git a/gdb/riscv-tdep.c b/gdb/riscv-tdep.c index 6943121007a..154567136eb 100644 --- a/gdb/riscv-tdep.c +++ b/gdb/riscv-tdep.c @@ -2103,7 +2103,7 @@ riscv_push_dummy_call (struct gdbarch *gdbarch, gdb_byte buf[sizeof (LONGEST)]; store_unsigned_integer (buf, call_info.xlen, byte_order, struct_addr); - regcache_cooked_write (regcache, RISCV_A0_REGNUM, buf); + regcache->cooked_write (RISCV_A0_REGNUM, buf); } for (i = 0; i < nargs; ++i) @@ -2124,9 +2124,7 @@ riscv_push_dummy_call (struct gdbarch *gdbarch, gdb_assert (info->argloc[0].c_length <= info->length); memset (tmp, 0, sizeof (tmp)); memcpy (tmp, info->contents, info->argloc[0].c_length); - regcache_cooked_write (regcache, - info->argloc[0].loc_data.regno, - tmp); + regcache->cooked_write (info->argloc[0].loc_data.regno, tmp); second_arg_length = ((info->argloc[0].c_length < info->length) ? info->argloc[1].c_length : 0); @@ -2163,9 +2161,7 @@ riscv_push_dummy_call (struct gdbarch *gdbarch, gdb_assert (second_arg_length <= call_info.xlen); memset (tmp, 0, sizeof (tmp)); memcpy (tmp, second_arg_data, second_arg_length); - regcache_cooked_write (regcache, - info->argloc[1].loc_data.regno, - tmp); + regcache->cooked_write (info->argloc[1].loc_data.regno, tmp); } break; @@ -2251,7 +2247,7 @@ riscv_return_value (struct gdbarch *gdbarch, regcache->cooked_read (regnum, readbuf); if (writebuf) - regcache_cooked_write (regcache, regnum, writebuf); + regcache->cooked_write (regnum, writebuf); /* A return value in register can have a second part in a second register. */ @@ -2271,7 +2267,7 @@ riscv_return_value (struct gdbarch *gdbarch, if (writebuf) { writebuf += info.argloc[1].c_offset; - regcache_cooked_write (regcache, regnum, writebuf); + regcache->cooked_write (regnum, writebuf); } break; diff --git a/gdb/rs6000-aix-tdep.c b/gdb/rs6000-aix-tdep.c index bb9e6be12ec..8e69c465fa7 100644 --- a/gdb/rs6000-aix-tdep.c +++ b/gdb/rs6000-aix-tdep.c @@ -250,7 +250,7 @@ rs6000_push_dummy_call (struct gdbarch *gdbarch, struct value *function, gdb_assert (len <= 8); target_float_convert (value_contents (arg), type, reg_val, reg_type); - regcache_cooked_write (regcache, fp_regnum, reg_val); + regcache->cooked_write (fp_regnum, reg_val); ++f_argno; } @@ -266,9 +266,7 @@ rs6000_push_dummy_call (struct gdbarch *gdbarch, struct value *function, ((char *) value_contents (arg)) + argbytes, (len - argbytes) > reg_size ? reg_size : len - argbytes); - regcache_cooked_write (regcache, - tdep->ppc_gp0_regnum + 3 + ii, - word); + regcache->cooked_write (tdep->ppc_gp0_regnum + 3 + ii, word); ++ii, argbytes += reg_size; if (ii >= 8) @@ -284,7 +282,7 @@ rs6000_push_dummy_call (struct gdbarch *gdbarch, struct value *function, memset (word, 0, reg_size); memcpy (word, value_contents (arg), len); - regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3 +ii, word); + regcache->cooked_write (tdep->ppc_gp0_regnum + 3 +ii, word); } ++argno; } @@ -366,9 +364,8 @@ ran_out_of_registers_for_arguments: gdb_assert (len <= 8); - regcache_cooked_write (regcache, - tdep->ppc_fp0_regnum + 1 + f_argno, - value_contents (arg)); + regcache->cooked_write (tdep->ppc_fp0_regnum + 1 + f_argno, + value_contents (arg)); ++f_argno; } @@ -422,7 +419,7 @@ rs6000_return_value (struct gdbarch *gdbarch, struct value *function, if (readbuf) regcache->cooked_read (tdep->ppc_vr0_regnum + 2, readbuf); if (writebuf) - regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + 2, writebuf); + regcache->cooked_write (tdep->ppc_vr0_regnum + 2, writebuf); return RETURN_VALUE_REGISTER_CONVENTION; } @@ -458,7 +455,7 @@ rs6000_return_value (struct gdbarch *gdbarch, struct value *function, if (writebuf) { target_float_convert (writebuf, valtype, regval, regtype); - regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, regval); + regcache->cooked_write (tdep->ppc_fp0_regnum + 1, regval); } return RETURN_VALUE_REGISTER_CONVENTION; @@ -510,9 +507,8 @@ rs6000_return_value (struct gdbarch *gdbarch, struct value *function, } if (writebuf) { - regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, writebuf); - regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4, - writebuf + 4); + regcache->cooked_write (tdep->ppc_gp0_regnum + 3, writebuf); + regcache->cooked_write (tdep->ppc_gp0_regnum + 4, writebuf + 4); } return RETURN_VALUE_REGISTER_CONVENTION; diff --git a/gdb/rs6000-lynx178-tdep.c b/gdb/rs6000-lynx178-tdep.c index 37ac61719a6..13eed3aeaea 100644 --- a/gdb/rs6000-lynx178-tdep.c +++ b/gdb/rs6000-lynx178-tdep.c @@ -112,7 +112,7 @@ rs6000_lynx178_push_dummy_call (struct gdbarch *gdbarch, gdb_assert (len <= 8); target_float_convert (value_contents (arg), type, reg_val, reg_type); - regcache_cooked_write (regcache, fp_regnum, reg_val); + regcache->cooked_write (fp_regnum, reg_val); ++f_argno; } @@ -128,9 +128,7 @@ rs6000_lynx178_push_dummy_call (struct gdbarch *gdbarch, ((char *) value_contents (arg)) + argbytes, (len - argbytes) > reg_size ? reg_size : len - argbytes); - regcache_cooked_write (regcache, - tdep->ppc_gp0_regnum + 3 + ii, - word); + regcache->cooked_write (tdep->ppc_gp0_regnum + 3 + ii, word); ++ii, argbytes += reg_size; if (ii >= 8) @@ -146,7 +144,7 @@ rs6000_lynx178_push_dummy_call (struct gdbarch *gdbarch, memset (word, 0, reg_size); memcpy (word, value_contents (arg), len); - regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3 +ii, word); + regcache->cooked_write (tdep->ppc_gp0_regnum + 3 +ii, word); } ++argno; } @@ -229,9 +227,8 @@ ran_out_of_registers_for_arguments: gdb_assert (len <= 8); - regcache_cooked_write (regcache, - tdep->ppc_fp0_regnum + 1 + f_argno, - value_contents (arg)); + regcache->cooked_write (tdep->ppc_fp0_regnum + 1 + f_argno, + value_contents (arg)); ++f_argno; } @@ -283,7 +280,7 @@ rs6000_lynx178_return_value (struct gdbarch *gdbarch, struct value *function, if (readbuf) regcache->cooked_read (tdep->ppc_vr0_regnum + 2, readbuf); if (writebuf) - regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + 2, writebuf); + regcache->cooked_write (tdep->ppc_vr0_regnum + 2, writebuf); return RETURN_VALUE_REGISTER_CONVENTION; } @@ -319,7 +316,7 @@ rs6000_lynx178_return_value (struct gdbarch *gdbarch, struct value *function, if (writebuf) { target_float_convert (writebuf, valtype, regval, regtype); - regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, regval); + regcache->cooked_write (tdep->ppc_fp0_regnum + 1, regval); } return RETURN_VALUE_REGISTER_CONVENTION; @@ -371,9 +368,8 @@ rs6000_lynx178_return_value (struct gdbarch *gdbarch, struct value *function, } if (writebuf) { - regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, writebuf); - regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4, - writebuf + 4); + regcache->cooked_write (tdep->ppc_gp0_regnum + 3, writebuf); + regcache->cooked_write (tdep->ppc_gp0_regnum + 4, writebuf + 4); } return RETURN_VALUE_REGISTER_CONVENTION; diff --git a/gdb/s390-tdep.c b/gdb/s390-tdep.c index 8a82fb96da8..eaf15504d5c 100644 --- a/gdb/s390-tdep.c +++ b/gdb/s390-tdep.c @@ -1800,12 +1800,10 @@ s390_handle_arg (struct s390_arg_state *as, struct value *arg, { if (write_mode) { - regcache_cooked_write (as->regcache, - S390_R0_REGNUM + as->gr, - value_contents (arg)); - regcache_cooked_write (as->regcache, - S390_R0_REGNUM + as->gr + 1, - value_contents (arg) + word_size); + as->regcache->cooked_write (S390_R0_REGNUM + as->gr, + value_contents (arg)); + as->regcache->cooked_write (S390_R0_REGNUM + as->gr + 1, + value_contents (arg) + word_size); } as->gr += 2; } @@ -2018,9 +2016,8 @@ s390_register_return_value (struct gdbarch *gdbarch, struct type *type, /* Double word: in r2 and r3. */ if (in != NULL) { - regcache_cooked_write (regcache, S390_R2_REGNUM, in); - regcache_cooked_write (regcache, S390_R3_REGNUM, - in + word_size); + regcache->cooked_write (S390_R2_REGNUM, in); + regcache->cooked_write (S390_R3_REGNUM, in + word_size); } else { diff --git a/gdb/sparc-tdep.c b/gdb/sparc-tdep.c index b3b3dcb4085..40d213f6d9d 100644 --- a/gdb/sparc-tdep.c +++ b/gdb/sparc-tdep.c @@ -685,9 +685,9 @@ sparc32_store_arguments (struct regcache *regcache, int nargs, { int regnum = SPARC_O0_REGNUM + element; - regcache_cooked_write (regcache, regnum, valbuf); + regcache->cooked_write (regnum, valbuf); if (len > 4 && element < 5) - regcache_cooked_write (regcache, regnum + 1, valbuf + 4); + regcache->cooked_write (regnum + 1, valbuf + 4); } /* Always store the argument in memory. */ @@ -1463,20 +1463,20 @@ sparc32_store_return_value (struct type *type, struct regcache *regcache, { /* Floating return values. */ memcpy (buf, valbuf, len); - regcache_cooked_write (regcache, SPARC_F0_REGNUM, buf); + regcache->cooked_write (SPARC_F0_REGNUM, buf); if (len > 4) - regcache_cooked_write (regcache, SPARC_F1_REGNUM, buf + 4); + regcache->cooked_write (SPARC_F1_REGNUM, buf + 4); if (len > 8) { - regcache_cooked_write (regcache, SPARC_F2_REGNUM, buf + 8); - regcache_cooked_write (regcache, SPARC_F3_REGNUM, buf + 12); + regcache->cooked_write (SPARC_F2_REGNUM, buf + 8); + regcache->cooked_write (SPARC_F3_REGNUM, buf + 12); } if (len > 16) { - regcache_cooked_write (regcache, SPARC_F4_REGNUM, buf + 16); - regcache_cooked_write (regcache, SPARC_F5_REGNUM, buf + 20); - regcache_cooked_write (regcache, SPARC_F6_REGNUM, buf + 24); - regcache_cooked_write (regcache, SPARC_F7_REGNUM, buf + 28); + regcache->cooked_write (SPARC_F4_REGNUM, buf + 16); + regcache->cooked_write (SPARC_F5_REGNUM, buf + 20); + regcache->cooked_write (SPARC_F6_REGNUM, buf + 24); + regcache->cooked_write (SPARC_F7_REGNUM, buf + 28); } } else @@ -1488,14 +1488,14 @@ sparc32_store_return_value (struct type *type, struct regcache *regcache, { gdb_assert (len == 8); memcpy (buf, valbuf, 8); - regcache_cooked_write (regcache, SPARC_O1_REGNUM, buf + 4); + regcache->cooked_write (SPARC_O1_REGNUM, buf + 4); } else { /* ??? Do we need to do any sign-extension here? */ memcpy (buf + 4 - len, valbuf, len); } - regcache_cooked_write (regcache, SPARC_O0_REGNUM, buf); + regcache->cooked_write (SPARC_O0_REGNUM, buf); } } diff --git a/gdb/sparc64-tdep.c b/gdb/sparc64-tdep.c index ed1aaffb2c8..dea8e4d4aeb 100644 --- a/gdb/sparc64-tdep.c +++ b/gdb/sparc64-tdep.c @@ -1226,7 +1226,7 @@ sparc64_store_floating_fields (struct regcache *regcache, struct type *type, len = 8; } for (int n = 0; n < (len + 3) / 4; n++) - regcache_cooked_write (regcache, regnum + n, valbuf + n * 4); + regcache->cooked_write (regnum + n, valbuf + n * 4); } else if (sparc64_floating_p (type) || (sparc64_complex_floating_p (type) && len <= 16)) @@ -1239,7 +1239,7 @@ sparc64_store_floating_fields (struct regcache *regcache, struct type *type, gdb_assert ((element % 2) == 0); regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM + element / 2; - regcache_cooked_write (regcache, regnum, valbuf); + regcache->cooked_write (regnum, valbuf); } else if (len == 8) { @@ -1247,7 +1247,7 @@ sparc64_store_floating_fields (struct regcache *regcache, struct type *type, regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM + element + bitpos / 64; - regcache_cooked_write (regcache, regnum, valbuf + (bitpos / 8)); + regcache->cooked_write (regnum, valbuf + (bitpos / 8)); } else { @@ -1255,7 +1255,7 @@ sparc64_store_floating_fields (struct regcache *regcache, struct type *type, gdb_assert (bitpos % 32 == 0 && bitpos >= 0 && bitpos < 128); regnum = SPARC_F0_REGNUM + element * 2 + bitpos / 32; - regcache_cooked_write (regcache, regnum, valbuf + (bitpos / 8)); + regcache->cooked_write (regnum, valbuf + (bitpos / 8)); } } else if (sparc64_structure_or_union_p (type)) @@ -1285,7 +1285,7 @@ sparc64_store_floating_fields (struct regcache *regcache, struct type *type, struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, 0)); if (sparc64_floating_p (subtype) && TYPE_LENGTH (subtype) == 4) - regcache_cooked_write (regcache, SPARC_F1_REGNUM, valbuf); + regcache->cooked_write (SPARC_F1_REGNUM, valbuf); } } } @@ -1506,7 +1506,7 @@ sparc64_store_arguments (struct regcache *regcache, int nargs, { regnum = SPARC_O0_REGNUM + element; if (len > 8 && element < 5) - regcache_cooked_write (regcache, regnum + 1, valbuf + 8); + regcache->cooked_write (regnum + 1, valbuf + 8); } if (element < 16) @@ -1522,11 +1522,10 @@ sparc64_store_arguments (struct regcache *regcache, int nargs, if (len == 16) { if (regnum < gdbarch_num_regs (gdbarch) + SPARC64_D30_REGNUM) - regcache_cooked_write (regcache, regnum + 1, valbuf + 8); + regcache->cooked_write (regnum + 1, valbuf + 8); if (regnum < gdbarch_num_regs (gdbarch) + SPARC64_D10_REGNUM) - regcache_cooked_write (regcache, - SPARC_O0_REGNUM + element + 1, - valbuf + 8); + regcache->cooked_write (SPARC_O0_REGNUM + element + 1, + valbuf + 8); } } } @@ -1574,7 +1573,7 @@ sparc64_store_arguments (struct regcache *regcache, int nargs, if (regnum != -1) { - regcache_cooked_write (regcache, regnum, valbuf); + regcache->cooked_write (regnum, valbuf); /* If we're storing the value in a floating-point register, also store it in the corresponding %0 register(s). */ @@ -1586,14 +1585,14 @@ sparc64_store_arguments (struct regcache *regcache, int nargs, { gdb_assert (element < 6); regnum = SPARC_O0_REGNUM + element; - regcache_cooked_write (regcache, regnum, valbuf); + regcache->cooked_write (regnum, valbuf); } else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q8_REGNUM) { gdb_assert (element < 5); regnum = SPARC_O0_REGNUM + element; - regcache_cooked_write (regcache, regnum, valbuf); - regcache_cooked_write (regcache, regnum + 1, valbuf + 8); + regcache->cooked_write (regnum, valbuf); + regcache->cooked_write (regnum + 1, valbuf + 8); } } } @@ -1715,7 +1714,7 @@ sparc64_store_return_value (struct type *type, struct regcache *regcache, memset (buf, 0, sizeof (buf)); memcpy (buf, valbuf, len); for (i = 0; i < ((len + 7) / 8); i++) - regcache_cooked_write (regcache, SPARC_O0_REGNUM + i, buf + i * 8); + regcache->cooked_write (SPARC_O0_REGNUM + i, buf + i * 8); if (TYPE_CODE (type) != TYPE_CODE_UNION) sparc64_store_floating_fields (regcache, type, buf, 0, 0); } @@ -1724,7 +1723,7 @@ sparc64_store_return_value (struct type *type, struct regcache *regcache, /* Floating return values. */ memcpy (buf, valbuf, len); for (i = 0; i < len / 4; i++) - regcache_cooked_write (regcache, SPARC_F0_REGNUM + i, buf + i * 4); + regcache->cooked_write (SPARC_F0_REGNUM + i, buf + i * 4); } else if (TYPE_CODE (type) == TYPE_CODE_ARRAY) { @@ -1734,7 +1733,7 @@ sparc64_store_return_value (struct type *type, struct regcache *regcache, memset (buf, 0, sizeof (buf)); memcpy (buf, valbuf, len); for (i = 0; i < ((len + 7) / 8); i++) - regcache_cooked_write (regcache, SPARC_O0_REGNUM + i, buf + i * 8); + regcache->cooked_write (SPARC_O0_REGNUM + i, buf + i * 8); } else { @@ -1744,7 +1743,7 @@ sparc64_store_return_value (struct type *type, struct regcache *regcache, /* ??? Do we need to do any sign-extension here? */ memset (buf, 0, 8); memcpy (buf + 8 - len, valbuf, len); - regcache_cooked_write (regcache, SPARC_O0_REGNUM, buf); + regcache->cooked_write (SPARC_O0_REGNUM, buf); } } diff --git a/gdb/spu-tdep.c b/gdb/spu-tdep.c index 1d0766effa1..d8a210726b9 100644 --- a/gdb/spu-tdep.c +++ b/gdb/spu-tdep.c @@ -1362,7 +1362,7 @@ spu_value_to_regcache (struct regcache *regcache, int regnum, { while (len >= 16) { - regcache_cooked_write (regcache, regnum++, in); + regcache->cooked_write (regnum++, in); in += 16; len -= 16; } @@ -1413,7 +1413,7 @@ spu_push_dummy_call (struct gdbarch *gdbarch, struct value *function, /* Set the return address. */ memset (buf, 0, sizeof buf); store_unsigned_integer (buf, 4, byte_order, SPUADDR_ADDR (bp_addr)); - regcache_cooked_write (regcache, SPU_LR_REGNUM, buf); + regcache->cooked_write (SPU_LR_REGNUM, buf); /* If STRUCT_RETURN is true, then the struct return address (in STRUCT_ADDR) will consume the first argument-passing register. @@ -1422,7 +1422,7 @@ spu_push_dummy_call (struct gdbarch *gdbarch, struct value *function, { memset (buf, 0, sizeof buf); store_unsigned_integer (buf, 4, byte_order, SPUADDR_ADDR (struct_addr)); - regcache_cooked_write (regcache, regnum++, buf); + regcache->cooked_write (regnum++, buf); } /* Fill in argument registers. */ @@ -1490,7 +1490,7 @@ spu_push_dummy_call (struct gdbarch *gdbarch, struct value *function, CORE_ADDR sp_slot = extract_unsigned_integer (buf + 4*i, 4, byte_order); store_unsigned_integer (buf + 4*i, 4, byte_order, sp_slot + sp_delta); } - regcache_cooked_write (regcache, SPU_RAW_SP_REGNUM, buf); + regcache->cooked_write (SPU_RAW_SP_REGNUM, buf); return sp; } diff --git a/gdb/tic6x-tdep.c b/gdb/tic6x-tdep.c index b2db026b32d..842fe3f5bbb 100644 --- a/gdb/tic6x-tdep.c +++ b/gdb/tic6x-tdep.c @@ -764,19 +764,19 @@ tic6x_store_return_value (struct type *valtype, struct regcache *regcache, regcache_cooked_write_part (regcache, TIC6X_A4_REGNUM, 4 - len, len, valbuf); else - regcache_cooked_write (regcache, TIC6X_A4_REGNUM, valbuf); + regcache->cooked_write (TIC6X_A4_REGNUM, valbuf); } else if (len <= 8) { if (byte_order == BFD_ENDIAN_BIG) { - regcache_cooked_write (regcache, TIC6X_A4_REGNUM, valbuf + 4); - regcache_cooked_write (regcache, TIC6X_A5_REGNUM, valbuf); + regcache->cooked_write (TIC6X_A4_REGNUM, valbuf + 4); + regcache->cooked_write (TIC6X_A5_REGNUM, valbuf); } else { - regcache_cooked_write (regcache, TIC6X_A4_REGNUM, valbuf); - regcache_cooked_write (regcache, TIC6X_A5_REGNUM, valbuf + 4); + regcache->cooked_write (TIC6X_A4_REGNUM, valbuf); + regcache->cooked_write (TIC6X_A5_REGNUM, valbuf + 4); } } } @@ -961,7 +961,7 @@ tic6x_push_dummy_call (struct gdbarch *gdbarch, struct value *function, regcache_cooked_write_part (regcache, arg_regs[argreg], 4 - len, len, val); else - regcache_cooked_write (regcache, arg_regs[argreg], val); + regcache->cooked_write (arg_regs[argreg], val); } else { @@ -988,16 +988,14 @@ tic6x_push_dummy_call (struct gdbarch *gdbarch, struct value *function, padding in the LSBs of the lower (even) register. */ if (byte_order == BFD_ENDIAN_BIG) { - regcache_cooked_write (regcache, - arg_regs[argreg] + 1, val); + regcache->cooked_write (arg_regs[argreg] + 1, val); regcache_cooked_write_part (regcache, arg_regs[argreg], 0, len - 4, val + 4); } else { - regcache_cooked_write (regcache, arg_regs[argreg], - val); + regcache->cooked_write (arg_regs[argreg], val); regcache_cooked_write_part (regcache, arg_regs[argreg] + 1, 0, len - 4, val + 4); diff --git a/gdb/vax-tdep.c b/gdb/vax-tdep.c index a1783ec0011..de07fdbb62e 100644 --- a/gdb/vax-tdep.c +++ b/gdb/vax-tdep.c @@ -133,7 +133,7 @@ vax_store_arguments (struct regcache *regcache, int nargs, /* Update the argument pointer. */ store_unsigned_integer (buf, 4, byte_order, sp); - regcache_cooked_write (regcache, VAX_AP_REGNUM, buf); + regcache->cooked_write (VAX_AP_REGNUM, buf); return sp; } @@ -180,8 +180,8 @@ vax_push_dummy_call (struct gdbarch *gdbarch, struct value *function, /* Update the stack pointer and frame pointer. */ store_unsigned_integer (buf, 4, byte_order, sp); - regcache_cooked_write (regcache, VAX_SP_REGNUM, buf); - regcache_cooked_write (regcache, VAX_FP_REGNUM, buf); + regcache->cooked_write (VAX_SP_REGNUM, buf); + regcache->cooked_write (VAX_FP_REGNUM, buf); /* Return the saved (fake) frame pointer. */ return fp; @@ -236,9 +236,9 @@ vax_return_value (struct gdbarch *gdbarch, struct value *function, { /* Read the contents to R0 and (if necessary) R1. */ memcpy (buf, writebuf, len); - regcache_cooked_write (regcache, VAX_R0_REGNUM, buf); + regcache->cooked_write (VAX_R0_REGNUM, buf); if (len > 4) - regcache_cooked_write (regcache, VAX_R1_REGNUM, buf + 4); + regcache->cooked_write (VAX_R1_REGNUM, buf + 4); } return RETURN_VALUE_REGISTER_CONVENTION; diff --git a/gdb/xtensa-tdep.c b/gdb/xtensa-tdep.c index 3785c44c878..1f87b9ca3ff 100644 --- a/gdb/xtensa-tdep.c +++ b/gdb/xtensa-tdep.c @@ -1846,7 +1846,7 @@ xtensa_push_dummy_call (struct gdbarch *gdbarch, if (struct_return) { store_unsigned_integer (buf, REGISTER_SIZE, byte_order, struct_addr); - regcache_cooked_write (regcache, ARG_1ST (gdbarch), buf); + regcache->cooked_write (ARG_1ST (gdbarch), buf); } for (i = 0; i < nargs; i++) @@ -1888,7 +1888,7 @@ xtensa_push_dummy_call (struct gdbarch *gdbarch, v = v >> ((REGISTER_SIZE - n) * TARGET_CHAR_BIT); store_unsigned_integer (buf, REGISTER_SIZE, byte_order, v); - regcache_cooked_write (regcache, r, buf); + regcache->cooked_write (r, buf); cp += REGISTER_SIZE; n -= REGISTER_SIZE; @@ -1897,7 +1897,7 @@ xtensa_push_dummy_call (struct gdbarch *gdbarch, else while (n > 0) { - regcache_cooked_write (regcache, r, cp); + regcache->cooked_write (r, cp); cp += REGISTER_SIZE; n -= REGISTER_SIZE; |