This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
[patch/comit] regcache read/write -> regcache raw read/write
- From: Andrew Cagney <ac131313 at ges dot redhat dot com>
- To: gdb-patches at sources dot redhat dot com
- Date: Mon, 22 Jul 2002 18:52:01 -0400
- Subject: [patch/comit] regcache read/write -> regcache raw read/write
Hello,
This patch starts to bring the regcache naming schema into line with its
proposed documentation (previous post).
Following on from this will be:
- corresponding cooked functions
- change to gdbarch to pass the register
cache to that function
I'll commit it tomorrow.
Andrew
2002-07-22 Andrew Cagney <cagney@redhat.com>
* regcache.h (regcache_raw_read, regcache_raw_write): Replace
regcache_read and regcache_write.
(regcache_raw_read_as_address): Replace regcache_read_as_address.
* regcache.c: Update.
* sh-tdep.c (sh64_push_arguments): Update comment.
(sh_pseudo_register_read): Update.
(sh_pseudo_register_write): Update.
(sh4_register_read): Update.
(sh4_register_write): Update.
(sh64_pseudo_register_read): Update.
(sh64_pseudo_register_write): Update.
(sh64_register_read): Update.
(sh64_register_write): Update.
* i386-tdep.c (i386_extract_return_value): Update.
(i386_extract_struct_value_address): Update.
(i386_extract_return_value):
* blockframe.c (generic_read_register_dummy): Update.
(generic_call_dummy_register_unwind): Update
* infrun.c (write_inferior_status_register): Update.
Index: blockframe.c
===================================================================
RCS file: /cvs/src/src/gdb/blockframe.c,v
retrieving revision 1.33
diff -u -r1.33 blockframe.c
--- blockframe.c 16 Jul 2002 07:42:25 -0000 1.33
+++ blockframe.c 22 Jul 2002 22:26:51 -0000
@@ -1215,7 +1215,7 @@
struct regcache *dummy_regs = generic_find_dummy_frame (pc, fp);
if (dummy_regs)
- return regcache_read_as_address (dummy_regs, regno);
+ return regcache_raw_read_as_address (dummy_regs, regno);
else
return 0;
}
@@ -1393,7 +1393,7 @@
gdbarch_register_read() method so that it, on the fly,
constructs either a raw or pseudo register from the raw
register cache. */
- regcache_read (registers, regnum, bufferp);
+ regcache_raw_read (registers, regnum, bufferp);
}
}
@@ -1543,8 +1543,9 @@
gdbarch_register_read() method so that it, on the fly,
constructs either a raw or pseudo register from the raw
register cache. */
- regcache_read (generic_find_dummy_frame (frame->pc, frame->frame),
- regnum, raw_buffer);
+ regcache_raw_read (generic_find_dummy_frame (frame->pc,
+ frame->frame),
+ regnum, raw_buffer);
return;
}
Index: i386-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/i386-tdep.c,v
retrieving revision 1.72
diff -u -r1.72 i386-tdep.c
--- i386-tdep.c 4 Jul 2002 08:18:20 -0000 1.72
+++ i386-tdep.c 22 Jul 2002 22:26:52 -0000
@@ -962,7 +962,7 @@
its contents to the desired type. This is probably not
exactly how it would happen on the target itself, but it is
the best we can do. */
- regcache_read (regcache, FP0_REGNUM, buf);
+ regcache_raw_read (regcache, FP0_REGNUM, buf);
convert_typed_floating (buf, builtin_type_i387_ext, valbuf, type);
}
else
@@ -972,14 +972,14 @@
if (len <= low_size)
{
- regcache_read (regcache, LOW_RETURN_REGNUM, buf);
+ regcache_raw_read (regcache, LOW_RETURN_REGNUM, buf);
memcpy (valbuf, buf, len);
}
else if (len <= (low_size + high_size))
{
- regcache_read (regcache, LOW_RETURN_REGNUM, buf);
+ regcache_raw_read (regcache, LOW_RETURN_REGNUM, buf);
memcpy (valbuf, buf, low_size);
- regcache_read (regcache, HIGH_RETURN_REGNUM, buf);
+ regcache_raw_read (regcache, HIGH_RETURN_REGNUM, buf);
memcpy (valbuf + low_size, buf, len - low_size);
}
else
@@ -1066,7 +1066,7 @@
static CORE_ADDR
i386_extract_struct_value_address (struct regcache *regcache)
{
- return regcache_read_as_address (regcache, LOW_RETURN_REGNUM);
+ return regcache_raw_read_as_address (regcache, LOW_RETURN_REGNUM);
}
Index: infrun.c
===================================================================
RCS file: /cvs/src/src/gdb/infrun.c,v
retrieving revision 1.63
diff -u -r1.63 infrun.c
--- infrun.c 18 Jul 2002 17:53:49 -0000 1.63
+++ infrun.c 22 Jul 2002 22:26:54 -0000
@@ -3917,7 +3917,7 @@
int size = REGISTER_RAW_SIZE (regno);
void *buf = alloca (size);
store_signed_integer (buf, size, val);
- regcache_write (inf_status->registers, regno, buf);
+ regcache_raw_write (inf_status->registers, regno, buf);
}
/* Save all of the information associated with the inferior<==>gdb
Index: regcache.c
===================================================================
RCS file: /cvs/src/src/gdb/regcache.c,v
retrieving revision 1.40
diff -u -r1.40 regcache.c
--- regcache.c 3 Jul 2002 20:36:54 -0000 1.40
+++ regcache.c 22 Jul 2002 22:26:54 -0000
@@ -312,8 +312,8 @@
for (i = 0; i < src->descr->nr_raw_registers; i++)
{
/* Should we worry about the valid bit here? */
- regcache_read (src, i, buf);
- regcache_write (dst, i, buf);
+ regcache_raw_read (src, i, buf);
+ regcache_raw_write (dst, i, buf);
}
}
@@ -362,13 +362,13 @@
}
CORE_ADDR
-regcache_read_as_address (struct regcache *regcache, int regnum)
+regcache_raw_read_as_address (struct regcache *regcache, int regnum)
{
char *buf;
gdb_assert (regcache != NULL);
gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
buf = alloca (regcache->descr->sizeof_register[regnum]);
- regcache_read (regcache, regnum, buf);
+ regcache_raw_read (regcache, regnum, buf);
return extract_address (buf, regcache->descr->sizeof_register[regnum]);
}
@@ -671,7 +671,7 @@
}
void
-regcache_read (struct regcache *regcache, int regnum, char *buf)
+regcache_raw_read (struct regcache *regcache, int regnum, char *buf)
{
gdb_assert (regcache != NULL && buf != NULL);
gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
@@ -761,7 +761,7 @@
}
void
-regcache_write (struct regcache *regcache, int regnum, char *buf)
+regcache_raw_write (struct regcache *regcache, int regnum, char *buf)
{
gdb_assert (regcache != NULL && buf != NULL);
gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
Index: regcache.h
===================================================================
RCS file: /cvs/src/src/gdb/regcache.h,v
retrieving revision 1.9
diff -u -r1.9 regcache.h
--- regcache.h 3 Jul 2002 20:36:54 -0000 1.9
+++ regcache.h 22 Jul 2002 22:26:54 -0000
@@ -35,10 +35,10 @@
/* Transfer a raw register [0..NUM_REGS) between core-gdb and the
regcache. */
-void regcache_read (struct regcache *regcache, int rawnum, char *buf);
-void regcache_write (struct regcache *regcache, int rawnum, char *buf);
+void regcache_raw_read (struct regcache *regcache, int rawnum, char *buf);
+void regcache_raw_write (struct regcache *regcache, int rawnum, char *buf);
int regcache_valid_p (struct regcache *regcache, int regnum);
-CORE_ADDR regcache_read_as_address (struct regcache *regcache, int rawnum);
+CORE_ADDR regcache_raw_read_as_address (struct regcache *regcache, int rawnum);
/* Transfer a raw register [0..NUM_REGS) between the regcache and the
target. These functions are called by the target in response to a
Index: sh-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/sh-tdep.c,v
retrieving revision 1.66
diff -u -r1.66 sh-tdep.c
--- sh-tdep.c 17 Jul 2002 18:43:28 -0000 1.66
+++ sh-tdep.c 22 Jul 2002 22:26:56 -0000
@@ -2251,11 +2251,12 @@
}
#endif
/* Note: must use write_register_gen here instead
- of regcache_write, because regcache_write works
- only for real registers, not pseudo.
- write_register_gen will call the gdbarch
- function to do register writes, and that will
- properly know how to deal with pseudoregs. */
+ of regcache_raw_write, because
+ regcache_raw_write works only for real
+ registers, not pseudo. write_register_gen will
+ call the gdbarch function to do register
+ writes, and that will properly know how to deal
+ with pseudoregs. */
write_register_gen (regnum, val);
fp_args[double_arg_index] = 1;
fp_args[double_arg_index + 1] = 1;
@@ -3385,9 +3386,9 @@
/* Build the value in the provided buffer. */
/* Read the real regs for which this one is an alias. */
for (portion = 0; portion < 2; portion++)
- regcache_read (current_regcache, base_regnum + portion,
- (temp_buffer
- + REGISTER_RAW_SIZE (base_regnum) * portion));
+ regcache_raw_read (current_regcache, base_regnum + portion,
+ (temp_buffer
+ + REGISTER_RAW_SIZE (base_regnum) * portion));
/* We must pay attention to the endiannes. */
sh_sh4_register_convert_to_virtual (reg_nr,
REGISTER_VIRTUAL_TYPE (reg_nr),
@@ -3400,8 +3401,8 @@
/* Read the real regs for which this one is an alias. */
for (portion = 0; portion < 4; portion++)
- regcache_read (current_regcache, base_regnum + portion,
- buffer + REGISTER_RAW_SIZE (base_regnum) * portion);
+ regcache_raw_read (current_regcache, base_regnum + portion,
+ buffer + REGISTER_RAW_SIZE (base_regnum) * portion);
}
}
@@ -3410,7 +3411,7 @@
{
if (reg_nr >= 0 && reg_nr < gdbarch_tdep (current_gdbarch)->DR0_REGNUM)
/* It is a regular register. */
- regcache_read (current_regcache, reg_nr, buffer);
+ regcache_raw_read (current_regcache, reg_nr, buffer);
else
/* It is a pseudo register and we need to construct its value */
sh_pseudo_register_read (reg_nr, buffer);
@@ -3434,9 +3435,9 @@
/* DR regs are double precision registers obtained by
concatenating 2 single precision floating point registers. */
for (portion = 0; portion < 2; portion++)
- regcache_read (current_regcache, base_regnum + portion,
- (temp_buffer
- + REGISTER_RAW_SIZE (base_regnum) * portion));
+ regcache_raw_read (current_regcache, base_regnum + portion,
+ (temp_buffer
+ + REGISTER_RAW_SIZE (base_regnum) * portion));
/* We must pay attention to the endiannes. */
sh_sh64_register_convert_to_virtual (reg_nr, REGISTER_VIRTUAL_TYPE (reg_nr),
@@ -3453,8 +3454,9 @@
/* FPP regs are pairs of single precision registers obtained by
concatenating 2 single precision floating point registers. */
for (portion = 0; portion < 2; portion++)
- regcache_read (current_regcache, base_regnum + portion,
- buffer + REGISTER_RAW_SIZE (base_regnum) * portion);
+ regcache_raw_read (current_regcache, base_regnum + portion,
+ (buffer
+ + REGISTER_RAW_SIZE (base_regnum) * portion));
}
else if (reg_nr >= tdep->FV0_REGNUM
@@ -3466,8 +3468,9 @@
/* FV regs are vectors of single precision registers obtained by
concatenating 4 single precision floating point registers. */
for (portion = 0; portion < 4; portion++)
- regcache_read (current_regcache, base_regnum + portion,
- buffer + REGISTER_RAW_SIZE (base_regnum) * portion);
+ regcache_raw_read (current_regcache, base_regnum + portion,
+ (buffer
+ + REGISTER_RAW_SIZE (base_regnum) * portion));
}
/* sh compact pseudo registers. 1-to-1 with a shmedia register */
@@ -3477,7 +3480,7 @@
base_regnum = sh64_compact_reg_base_num (reg_nr);
/* Build the value in the provided buffer. */
- regcache_read (current_regcache, base_regnum, temp_buffer);
+ regcache_raw_read (current_regcache, base_regnum, temp_buffer);
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
offset = 4;
memcpy (buffer, temp_buffer + offset, 4); /* get LOWER 32 bits only????*/
@@ -3491,7 +3494,7 @@
/* Build the value in the provided buffer. */
/* Floating point registers map 1-1 to the media fp regs,
they have the same size and endienness. */
- regcache_read (current_regcache, base_regnum, buffer);
+ regcache_raw_read (current_regcache, base_regnum, buffer);
}
else if (reg_nr >= tdep->DR0_C_REGNUM
@@ -3502,9 +3505,9 @@
/* DR_C regs are double precision registers obtained by
concatenating 2 single precision floating point registers. */
for (portion = 0; portion < 2; portion++)
- regcache_read (current_regcache, base_regnum + portion,
- (temp_buffer
- + REGISTER_RAW_SIZE (base_regnum) * portion));
+ regcache_raw_read (current_regcache, base_regnum + portion,
+ (temp_buffer
+ + REGISTER_RAW_SIZE (base_regnum) * portion));
/* We must pay attention to the endiannes. */
sh_sh64_register_convert_to_virtual (reg_nr, REGISTER_VIRTUAL_TYPE (reg_nr),
@@ -3520,8 +3523,9 @@
/* FV_C regs are vectors of single precision registers obtained by
concatenating 4 single precision floating point registers. */
for (portion = 0; portion < 4; portion++)
- regcache_read (current_regcache, base_regnum + portion,
- buffer + REGISTER_RAW_SIZE (base_regnum) * portion);
+ regcache_raw_read (current_regcache, base_regnum + portion,
+ (buffer
+ + REGISTER_RAW_SIZE (base_regnum) * portion));
}
else if (reg_nr == tdep->FPSCR_C_REGNUM)
@@ -3552,11 +3556,11 @@
*/
/* *INDENT-ON* */
/* Get FPSCR into a local buffer */
- regcache_read (current_regcache, fpscr_base_regnum, temp_buffer);
+ regcache_raw_read (current_regcache, fpscr_base_regnum, temp_buffer);
/* Get value as an int. */
fpscr_value = extract_unsigned_integer (temp_buffer, 4);
/* Get SR into a local buffer */
- regcache_read (current_regcache, sr_base_regnum, temp_buffer);
+ regcache_raw_read (current_regcache, sr_base_regnum, temp_buffer);
/* Get value as an int. */
sr_value = extract_unsigned_integer (temp_buffer, 4);
/* Build the new value. */
@@ -3574,7 +3578,7 @@
/* FPUL_C register is floating point register 32,
same size, same endianness. */
- regcache_read (current_regcache, base_regnum, buffer);
+ regcache_raw_read (current_regcache, base_regnum, buffer);
}
}
@@ -3584,7 +3588,7 @@
if (reg_nr >= 0 && reg_nr < gdbarch_tdep (current_gdbarch)->DR0_REGNUM)
/* It is a regular register. */
- regcache_read (current_regcache, reg_nr, buffer);
+ regcache_raw_read (current_regcache, reg_nr, buffer);
else
/* It is a pseudo register and we need to construct its value */
sh64_pseudo_register_read (reg_nr, buffer);
@@ -3608,9 +3612,9 @@
/* Write the real regs for which this one is an alias. */
for (portion = 0; portion < 2; portion++)
- regcache_write (current_regcache, base_regnum + portion,
- (temp_buffer
- + REGISTER_RAW_SIZE (base_regnum) * portion));
+ regcache_raw_write (current_regcache, base_regnum + portion,
+ (temp_buffer
+ + REGISTER_RAW_SIZE (base_regnum) * portion));
}
else if (reg_nr >= tdep->FV0_REGNUM
&& reg_nr <= tdep->FV_LAST_REGNUM)
@@ -3619,8 +3623,9 @@
/* Write the real regs for which this one is an alias. */
for (portion = 0; portion < 4; portion++)
- regcache_write (current_regcache, base_regnum + portion,
- buffer + REGISTER_RAW_SIZE (base_regnum) * portion);
+ regcache_raw_write (current_regcache, base_regnum + portion,
+ (buffer
+ + REGISTER_RAW_SIZE (base_regnum) * portion));
}
}
@@ -3629,7 +3634,7 @@
{
if (reg_nr >= 0 && reg_nr < gdbarch_tdep (current_gdbarch)->DR0_REGNUM)
/* It is a regular register. */
- regcache_write (current_regcache, reg_nr, buffer);
+ regcache_raw_write (current_regcache, reg_nr, buffer);
else
/* It is a pseudo register and we need to construct its value */
sh_pseudo_register_write (reg_nr, buffer);
@@ -3654,9 +3659,9 @@
/* Write the real regs for which this one is an alias. */
for (portion = 0; portion < 2; portion++)
- regcache_write (current_regcache, base_regnum + portion,
- (temp_buffer
- + REGISTER_RAW_SIZE (base_regnum) * portion));
+ regcache_raw_write (current_regcache, base_regnum + portion,
+ (temp_buffer
+ + REGISTER_RAW_SIZE (base_regnum) * portion));
}
else if (reg_nr >= tdep->FPP0_REGNUM
@@ -3666,8 +3671,9 @@
/* Write the real regs for which this one is an alias. */
for (portion = 0; portion < 2; portion++)
- regcache_write (current_regcache, base_regnum + portion,
- buffer + REGISTER_RAW_SIZE (base_regnum) * portion);
+ regcache_raw_write (current_regcache, base_regnum + portion,
+ (buffer
+ + REGISTER_RAW_SIZE (base_regnum) * portion));
}
else if (reg_nr >= tdep->FV0_REGNUM
@@ -3677,8 +3683,9 @@
/* Write the real regs for which this one is an alias. */
for (portion = 0; portion < 4; portion++)
- regcache_write (current_regcache, base_regnum + portion,
- buffer + REGISTER_RAW_SIZE (base_regnum) * portion);
+ regcache_raw_write (current_regcache, base_regnum + portion,
+ (buffer
+ + REGISTER_RAW_SIZE (base_regnum) * portion));
}
/* sh compact general pseudo registers. 1-to-1 with a shmedia
@@ -3695,10 +3702,10 @@
/* Let's read the value of the base register into a temporary
buffer, so that overwriting the last four bytes with the new
value of the pseudo will leave the upper 4 bytes unchanged. */
- regcache_read (current_regcache, base_regnum, temp_buffer);
+ regcache_raw_read (current_regcache, base_regnum, temp_buffer);
/* Write as an 8 byte quantity */
memcpy (temp_buffer + offset, buffer, 4);
- regcache_write (current_regcache, base_regnum, temp_buffer);
+ regcache_raw_write (current_regcache, base_regnum, temp_buffer);
}
/* sh floating point compact pseudo registers. 1-to-1 with a shmedia
@@ -3707,7 +3714,7 @@
&& reg_nr <= tdep->FP_LAST_C_REGNUM)
{
base_regnum = sh64_compact_reg_base_num (reg_nr);
- regcache_write (current_regcache, base_regnum, buffer);
+ regcache_raw_write (current_regcache, base_regnum, buffer);
}
else if (reg_nr >= tdep->DR0_C_REGNUM
@@ -3720,9 +3727,9 @@
sh_sh64_register_convert_to_raw (REGISTER_VIRTUAL_TYPE (reg_nr), reg_nr,
buffer, temp_buffer);
- regcache_write (current_regcache, base_regnum + portion,
- (temp_buffer
- + REGISTER_RAW_SIZE (base_regnum) * portion));
+ regcache_raw_write (current_regcache, base_regnum + portion,
+ (temp_buffer
+ + REGISTER_RAW_SIZE (base_regnum) * portion));
}
}
@@ -3733,8 +3740,9 @@
for (portion = 0; portion < 4; portion++)
{
- regcache_write (current_regcache, base_regnum + portion,
- buffer + REGISTER_RAW_SIZE (base_regnum) * portion);
+ regcache_raw_write (current_regcache, base_regnum + portion,
+ (buffer
+ + REGISTER_RAW_SIZE (base_regnum) * portion));
}
}
@@ -3776,25 +3784,25 @@
fpscr_value = fpscr_c_value & fpscr_mask;
sr_value = (fpscr_value & sr_mask) >> 6;
- regcache_read (current_regcache, fpscr_base_regnum, temp_buffer);
+ regcache_raw_read (current_regcache, fpscr_base_regnum, temp_buffer);
old_fpscr_value = extract_unsigned_integer (temp_buffer, 4);
old_fpscr_value &= 0xfffc0002;
fpscr_value |= old_fpscr_value;
store_unsigned_integer (temp_buffer, 4, fpscr_value);
- regcache_write (current_regcache, fpscr_base_regnum, temp_buffer);
+ regcache_raw_write (current_regcache, fpscr_base_regnum, temp_buffer);
- regcache_read (current_regcache, sr_base_regnum, temp_buffer);
+ regcache_raw_read (current_regcache, sr_base_regnum, temp_buffer);
old_sr_value = extract_unsigned_integer (temp_buffer, 4);
old_sr_value &= 0xffff8fff;
sr_value |= old_sr_value;
store_unsigned_integer (temp_buffer, 4, sr_value);
- regcache_write (current_regcache, sr_base_regnum, temp_buffer);
+ regcache_raw_write (current_regcache, sr_base_regnum, temp_buffer);
}
else if (reg_nr == tdep->FPUL_C_REGNUM)
{
base_regnum = sh64_compact_reg_base_num (reg_nr);
- regcache_write (current_regcache, base_regnum, buffer);
+ regcache_raw_write (current_regcache, base_regnum, buffer);
}
}
@@ -3803,7 +3811,7 @@
{
if (reg_nr >= 0 && reg_nr < gdbarch_tdep (current_gdbarch)->DR0_REGNUM)
/* It is a regular register. */
- regcache_write (current_regcache, reg_nr, buffer);
+ regcache_raw_write (current_regcache, reg_nr, buffer);
else
/* It is a pseudo register and we need to construct its value */
sh64_pseudo_register_write (reg_nr, buffer);