Remove regcache_cooked_write
Remove regcache_cooked_write, update callers to use regcache::cooked_write. gdb/ChangeLog: * regcache.h (regcache_cooked_write): Remove, update callers to use regcache::cooked_write. * regcache.c (regcache_cooked_write): Remove.
This commit is contained in:
parent
6aa7d72401
commit
b66f5587de
|
@ -1,3 +1,9 @@
|
|||
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
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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:
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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."));
|
||||
|
|
|
@ -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__,
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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. */
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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)
|
||||
{
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -771,13 +771,6 @@ regcache::raw_write (int regnum, const gdb_byte *buf)
|
|||
invalidator.release ();
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
|
|
|
@ -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);
|
||||
|
||||
|
|
|
@ -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;
|
||||
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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
|
||||
{
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
Loading…
Reference in New Issue