This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
[patch/rfc/rfa:sh] gdbarch_register_read() -> gdbarch_cooked_register_read()
- From: Andrew Cagney <ac131313 at ges dot redhat dot com>
- To: gdb-patches at sources dot redhat dot com
- Date: Wed, 24 Jul 2002 19:14:07 -0400
- Subject: [patch/rfc/rfa:sh] gdbarch_register_read() -> gdbarch_cooked_register_read()
Hello,
The attached patch replaces the architecture vector interface:
void gdbarch_register_read (struct gdbarch *gdbarch, int regnum, char
*buf);
with the new interface:
void gdbarch_cooked_register_read (struct gdbarch *gdbarch, struct
regcache *regcache, int regnum, void *buf)
and then fixes the consequnces (all syntatic).
One NB. The parameter set is technically redundant. The assertion:
gdbarch == regcache_gdbarch (regcache)
always holds so the gdbarch parameter isn't strictly needed. I figured
that it is more convenient to include the gdbarch as a parameter and
save everyone the hassle of including the above line in their *-tdep code.
The SH stuff should be reviewed. I think its on the right track since
sh-tdep.c no longer refers to current_regcache!!!
comments? sh ok?
Andrew
2002-07-24 Andrew Cagney <cagney@redhat.com>
* gdbarch.sh (cooked_register_read, cooked_register_write):
Replace the architecture methods register_read and register_write.
* gdbarch.h, gdbarch.c: Regenerate.
* sh-tdep.c (sh_gdbarch_init): Update.
(sh4_cooked_register_write): Replace sh4_register_write.
(sh4_cooked_register_read): Replace sh4_register_read.
(sh64_cooked_register_read): Replace sh64_register_read.
(sh64_cooked_register_write): Replace sh64_register_write.
(sh_pseudo_register_read, sh64_pseudo_register_read): Add `tdep'
and `regcache' parameters, use.
(sh_pseudo_register_write, sh64_pseudo_register_write): Add `tdep'
and `regcache' parameters, use. Make `buffer' parameter a
constaint pointer.
(sh_sh4_register_convert_to_raw)
(sh_sh64_register_convert_to_raw): Make `from' parameter a
constant void pointer. Make `to' parameter a void pointer.
* regcache.c (init_regcache_descr): Update.
(read_register_gen): Update.
(write_register_gen): Update.
(supply_register): Update comment.
Index: gdbarch.sh
===================================================================
RCS file: /cvs/src/src/gdb/gdbarch.sh,v
retrieving revision 1.149
diff -u -r1.149 gdbarch.sh
--- gdbarch.sh 11 Jul 2002 13:50:49 -0000 1.149
+++ gdbarch.sh 24 Jul 2002 23:00:30 -0000
@@ -428,8 +428,8 @@
# serious shakedown.
f::TARGET_VIRTUAL_FRAME_POINTER:void:virtual_frame_pointer:CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset:pc, frame_regnum, frame_offset::0:legacy_virtual_frame_pointer::0
#
-M:::void:register_read:int regnum, char *buf:regnum, buf:
-M:::void:register_write:int regnum, char *buf:regnum, buf:
+M:::void:cooked_register_read:struct regcache *regcache, int regnum, void *buf:regcache, regnum, buf:
+M:::void:cooked_register_write:struct regcache *regcache, int regnum, const void *buf:regcache, regnum, buf:
#
v:2:NUM_REGS:int:num_regs::::0:-1
# This macro gives the number of pseudo-registers that live in the
Index: regcache.c
===================================================================
RCS file: /cvs/src/src/gdb/regcache.c,v
retrieving revision 1.42
diff -u -r1.42 regcache.c
--- regcache.c 24 Jul 2002 19:43:43 -0000 1.42
+++ regcache.c 24 Jul 2002 23:00:30 -0000
@@ -140,8 +140,8 @@
/* If an old style architecture, construct the register cache
description using all the register macros. */
- if (!gdbarch_register_read_p (gdbarch)
- && !gdbarch_register_write_p (gdbarch))
+ if (!gdbarch_cooked_register_read_p (gdbarch)
+ && !gdbarch_cooked_register_write_p (gdbarch))
return init_legacy_regcache_descr (gdbarch);
descr = XMALLOC (struct regcache_descr);
@@ -716,7 +716,8 @@
legacy_read_register_gen (regnum, buf);
return;
}
- gdbarch_register_read (current_gdbarch, regnum, buf);
+ gdbarch_cooked_register_read (current_gdbarch, current_regcache,
+ regnum, buf);
}
@@ -825,7 +826,8 @@
legacy_write_register_gen (regnum, buf);
return;
}
- gdbarch_register_write (current_gdbarch, regnum, buf);
+ gdbarch_cooked_register_write (current_gdbarch, current_regcache,
+ regnum, buf);
}
/* Copy INLEN bytes of consecutive data from memory at MYADDR
@@ -1011,7 +1013,7 @@
/* NOTE: cagney/2001-03-16: The macro CLEAN_UP_REGISTER_VALUE is
going to be deprecated. Instead architectures will leave the raw
register value as is and instead clean things up as they pass
- through the method gdbarch_register_read() clean up the
+ through the method gdbarch_cooked_register_read() clean up the
values. */
#ifdef DEPRECATED_CLEAN_UP_REGISTER_VALUE
Index: sh-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/sh-tdep.c,v
retrieving revision 1.67
diff -u -r1.67 sh-tdep.c
--- sh-tdep.c 24 Jul 2002 14:38:55 -0000 1.67
+++ sh-tdep.c 24 Jul 2002 23:00:32 -0000
@@ -3332,7 +3332,7 @@
static void
sh_sh4_register_convert_to_raw (struct type *type, int regnum,
- char *from, char *to)
+ const void *from, void *to)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
@@ -3348,7 +3348,7 @@
void
sh_sh64_register_convert_to_raw (struct type *type, int regnum,
- char *from, char *to)
+ const void *from, void *to)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
@@ -3372,11 +3372,11 @@
}
void
-sh_pseudo_register_read (int reg_nr, char *buffer)
+sh_pseudo_register_read (struct gdbarch_tdep *tdep, struct regcache *regcache,
+ int reg_nr, char *buffer)
{
int base_regnum, portion;
char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
if (reg_nr >= tdep->DR0_REGNUM
&& reg_nr <= tdep->DR_LAST_REGNUM)
@@ -3386,7 +3386,7 @@
/* 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_raw_read (current_regcache, base_regnum + portion,
+ regcache_raw_read (regcache, base_regnum + portion,
(temp_buffer
+ REGISTER_RAW_SIZE (base_regnum) * portion));
/* We must pay attention to the endiannes. */
@@ -3401,30 +3401,33 @@
/* Read the real regs for which this one is an alias. */
for (portion = 0; portion < 4; portion++)
- regcache_raw_read (current_regcache, base_regnum + portion,
+ regcache_raw_read (regcache, base_regnum + portion,
buffer + REGISTER_RAW_SIZE (base_regnum) * portion);
}
}
static void
-sh4_register_read (struct gdbarch *gdbarch, int reg_nr, char *buffer)
+sh4_cooked_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
+ int reg_nr, void *buffer)
{
- if (reg_nr >= 0 && reg_nr < gdbarch_tdep (current_gdbarch)->DR0_REGNUM)
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ if (reg_nr >= 0 && reg_nr < tdep->DR0_REGNUM)
/* It is a regular register. */
- regcache_raw_read (current_regcache, reg_nr, buffer);
+ regcache_raw_read (regcache, reg_nr, buffer);
else
/* It is a pseudo register and we need to construct its value */
- sh_pseudo_register_read (reg_nr, buffer);
+ sh_pseudo_register_read (tdep, regcache, reg_nr, buffer);
}
static void
-sh64_pseudo_register_read (int reg_nr, char *buffer)
+sh64_pseudo_register_read (struct gdbarch_tdep *tdep,
+ struct regcache *regcache,
+ int reg_nr, char *buffer)
{
int base_regnum;
int portion;
int offset = 0;
char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
if (reg_nr >= tdep->DR0_REGNUM
&& reg_nr <= tdep->DR_LAST_REGNUM)
@@ -3435,7 +3438,7 @@
/* DR regs are double precision registers obtained by
concatenating 2 single precision floating point registers. */
for (portion = 0; portion < 2; portion++)
- regcache_raw_read (current_regcache, base_regnum + portion,
+ regcache_raw_read (regcache, base_regnum + portion,
(temp_buffer
+ REGISTER_RAW_SIZE (base_regnum) * portion));
@@ -3454,7 +3457,7 @@
/* FPP regs are pairs of single precision registers obtained by
concatenating 2 single precision floating point registers. */
for (portion = 0; portion < 2; portion++)
- regcache_raw_read (current_regcache, base_regnum + portion,
+ regcache_raw_read (regcache, base_regnum + portion,
(buffer
+ REGISTER_RAW_SIZE (base_regnum) * portion));
}
@@ -3468,7 +3471,7 @@
/* FV regs are vectors of single precision registers obtained by
concatenating 4 single precision floating point registers. */
for (portion = 0; portion < 4; portion++)
- regcache_raw_read (current_regcache, base_regnum + portion,
+ regcache_raw_read (regcache, base_regnum + portion,
(buffer
+ REGISTER_RAW_SIZE (base_regnum) * portion));
}
@@ -3480,7 +3483,7 @@
base_regnum = sh64_compact_reg_base_num (reg_nr);
/* Build the value in the provided buffer. */
- regcache_raw_read (current_regcache, base_regnum, temp_buffer);
+ regcache_raw_read (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????*/
@@ -3494,7 +3497,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_raw_read (current_regcache, base_regnum, buffer);
+ regcache_raw_read (regcache, base_regnum, buffer);
}
else if (reg_nr >= tdep->DR0_C_REGNUM
@@ -3505,7 +3508,7 @@
/* DR_C regs are double precision registers obtained by
concatenating 2 single precision floating point registers. */
for (portion = 0; portion < 2; portion++)
- regcache_raw_read (current_regcache, base_regnum + portion,
+ regcache_raw_read (regcache, base_regnum + portion,
(temp_buffer
+ REGISTER_RAW_SIZE (base_regnum) * portion));
@@ -3523,7 +3526,7 @@
/* 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_raw_read (current_regcache, base_regnum + portion,
+ regcache_raw_read (regcache, base_regnum + portion,
(buffer
+ REGISTER_RAW_SIZE (base_regnum) * portion));
}
@@ -3556,11 +3559,11 @@
*/
/* *INDENT-ON* */
/* Get FPSCR into a local buffer */
- regcache_raw_read (current_regcache, fpscr_base_regnum, temp_buffer);
+ regcache_raw_read (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_raw_read (current_regcache, sr_base_regnum, temp_buffer);
+ regcache_raw_read (regcache, sr_base_regnum, temp_buffer);
/* Get value as an int. */
sr_value = extract_unsigned_integer (temp_buffer, 4);
/* Build the new value. */
@@ -3578,28 +3581,29 @@
/* FPUL_C register is floating point register 32,
same size, same endianness. */
- regcache_raw_read (current_regcache, base_regnum, buffer);
+ regcache_raw_read (regcache, base_regnum, buffer);
}
}
static void
-sh64_register_read (struct gdbarch *gdbarch, int reg_nr, char *buffer)
+sh64_cooked_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
+ int reg_nr, void *buffer)
{
-
- if (reg_nr >= 0 && reg_nr < gdbarch_tdep (current_gdbarch)->DR0_REGNUM)
+ struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ if (reg_nr >= 0 && reg_nr < tdep->DR0_REGNUM)
/* It is a regular register. */
- regcache_raw_read (current_regcache, reg_nr, buffer);
+ regcache_raw_read (regcache, reg_nr, buffer);
else
/* It is a pseudo register and we need to construct its value */
- sh64_pseudo_register_read (reg_nr, buffer);
+ sh64_pseudo_register_read (tdep, regcache, reg_nr, buffer);
}
void
-sh_pseudo_register_write (int reg_nr, char *buffer)
+sh_pseudo_register_write (struct gdbarch_tdep *tdep, struct regcache *regcache,
+ int reg_nr, const char *buffer)
{
int base_regnum, portion;
char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
if (reg_nr >= tdep->DR0_REGNUM
&& reg_nr <= tdep->DR_LAST_REGNUM)
@@ -3612,7 +3616,7 @@
/* Write the real regs for which this one is an alias. */
for (portion = 0; portion < 2; portion++)
- regcache_raw_write (current_regcache, base_regnum + portion,
+ regcache_raw_write (regcache, base_regnum + portion,
(temp_buffer
+ REGISTER_RAW_SIZE (base_regnum) * portion));
}
@@ -3623,30 +3627,33 @@
/* Write the real regs for which this one is an alias. */
for (portion = 0; portion < 4; portion++)
- regcache_raw_write (current_regcache, base_regnum + portion,
+ regcache_raw_write (regcache, base_regnum + portion,
(buffer
+ REGISTER_RAW_SIZE (base_regnum) * portion));
}
}
static void
-sh4_register_write (struct gdbarch *gdbarch, int reg_nr, char *buffer)
+sh4_cooked_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
+ int reg_nr, const void *buffer)
{
- if (reg_nr >= 0 && reg_nr < gdbarch_tdep (current_gdbarch)->DR0_REGNUM)
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ if (reg_nr >= 0 && reg_nr < tdep->DR0_REGNUM)
/* It is a regular register. */
- regcache_raw_write (current_regcache, reg_nr, buffer);
+ regcache_raw_write (regcache, reg_nr, buffer);
else
/* It is a pseudo register and we need to construct its value */
- sh_pseudo_register_write (reg_nr, buffer);
+ sh_pseudo_register_write (tdep, regcache, reg_nr, buffer);
}
void
-sh64_pseudo_register_write (int reg_nr, char *buffer)
+sh64_pseudo_register_write (struct gdbarch_tdep *tdep,
+ struct regcache *regcache,
+ int reg_nr, const char *buffer)
{
int base_regnum, portion;
int offset;
char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
if (reg_nr >= tdep->DR0_REGNUM
&& reg_nr <= tdep->DR_LAST_REGNUM)
@@ -3659,7 +3666,7 @@
/* Write the real regs for which this one is an alias. */
for (portion = 0; portion < 2; portion++)
- regcache_raw_write (current_regcache, base_regnum + portion,
+ regcache_raw_write (regcache, base_regnum + portion,
(temp_buffer
+ REGISTER_RAW_SIZE (base_regnum) * portion));
}
@@ -3671,7 +3678,7 @@
/* Write the real regs for which this one is an alias. */
for (portion = 0; portion < 2; portion++)
- regcache_raw_write (current_regcache, base_regnum + portion,
+ regcache_raw_write (regcache, base_regnum + portion,
(buffer
+ REGISTER_RAW_SIZE (base_regnum) * portion));
}
@@ -3683,7 +3690,7 @@
/* Write the real regs for which this one is an alias. */
for (portion = 0; portion < 4; portion++)
- regcache_raw_write (current_regcache, base_regnum + portion,
+ regcache_raw_write (regcache, base_regnum + portion,
(buffer
+ REGISTER_RAW_SIZE (base_regnum) * portion));
}
@@ -3702,10 +3709,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_raw_read (current_regcache, base_regnum, temp_buffer);
+ regcache_raw_read (regcache, base_regnum, temp_buffer);
/* Write as an 8 byte quantity */
memcpy (temp_buffer + offset, buffer, 4);
- regcache_raw_write (current_regcache, base_regnum, temp_buffer);
+ regcache_raw_write (regcache, base_regnum, temp_buffer);
}
/* sh floating point compact pseudo registers. 1-to-1 with a shmedia
@@ -3714,7 +3721,7 @@
&& reg_nr <= tdep->FP_LAST_C_REGNUM)
{
base_regnum = sh64_compact_reg_base_num (reg_nr);
- regcache_raw_write (current_regcache, base_regnum, buffer);
+ regcache_raw_write (regcache, base_regnum, buffer);
}
else if (reg_nr >= tdep->DR0_C_REGNUM
@@ -3727,7 +3734,7 @@
sh_sh64_register_convert_to_raw (REGISTER_VIRTUAL_TYPE (reg_nr), reg_nr,
buffer, temp_buffer);
- regcache_raw_write (current_regcache, base_regnum + portion,
+ regcache_raw_write (regcache, base_regnum + portion,
(temp_buffer
+ REGISTER_RAW_SIZE (base_regnum) * portion));
}
@@ -3740,7 +3747,7 @@
for (portion = 0; portion < 4; portion++)
{
- regcache_raw_write (current_regcache, base_regnum + portion,
+ regcache_raw_write (regcache, base_regnum + portion,
(buffer
+ REGISTER_RAW_SIZE (base_regnum) * portion));
}
@@ -3784,37 +3791,39 @@
fpscr_value = fpscr_c_value & fpscr_mask;
sr_value = (fpscr_value & sr_mask) >> 6;
- regcache_raw_read (current_regcache, fpscr_base_regnum, temp_buffer);
+ regcache_raw_read (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_raw_write (current_regcache, fpscr_base_regnum, temp_buffer);
+ regcache_raw_write (regcache, fpscr_base_regnum, temp_buffer);
- regcache_raw_read (current_regcache, sr_base_regnum, temp_buffer);
+ regcache_raw_read (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_raw_write (current_regcache, sr_base_regnum, temp_buffer);
+ regcache_raw_write (regcache, sr_base_regnum, temp_buffer);
}
else if (reg_nr == tdep->FPUL_C_REGNUM)
{
base_regnum = sh64_compact_reg_base_num (reg_nr);
- regcache_raw_write (current_regcache, base_regnum, buffer);
+ regcache_raw_write (regcache, base_regnum, buffer);
}
}
static void
-sh64_register_write (struct gdbarch *gdbarch, int reg_nr, char *buffer)
+sh64_cooked_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
+ int reg_nr, const void *buffer)
{
- if (reg_nr >= 0 && reg_nr < gdbarch_tdep (current_gdbarch)->DR0_REGNUM)
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ if (reg_nr >= 0 && reg_nr < tdep->DR0_REGNUM)
/* It is a regular register. */
- regcache_raw_write (current_regcache, reg_nr, buffer);
+ regcache_raw_write (regcache, reg_nr, buffer);
else
/* It is a pseudo register and we need to construct its value */
- sh64_pseudo_register_write (reg_nr, buffer);
+ sh64_pseudo_register_write (tdep, regcache, reg_nr, buffer);
}
/* Floating point vector of 4 float registers. */
@@ -4449,8 +4458,8 @@
set_gdbarch_num_pseudo_regs (gdbarch, 12);
set_gdbarch_max_register_raw_size (gdbarch, 4 * 4);
set_gdbarch_max_register_virtual_size (gdbarch, 4 * 4);
- set_gdbarch_register_read (gdbarch, sh4_register_read);
- set_gdbarch_register_write (gdbarch, sh4_register_write);
+ set_gdbarch_cooked_register_read (gdbarch, sh4_cooked_register_read);
+ set_gdbarch_cooked_register_write (gdbarch, sh4_cooked_register_write);
tdep->FPUL_REGNUM = 23;
tdep->FPSCR_REGNUM = 24;
tdep->FP_LAST_REGNUM = 40;
@@ -4541,8 +4550,8 @@
/* Or should that go in the virtual_size? */
/*set_gdbarch_max_register_virtual_size (gdbarch, 8);*/
set_gdbarch_max_register_virtual_size (gdbarch, 4 * 4);
- set_gdbarch_register_read (gdbarch, sh64_register_read);
- set_gdbarch_register_write (gdbarch, sh64_register_write);
+ set_gdbarch_cooked_register_read (gdbarch, sh64_cooked_register_read);
+ set_gdbarch_cooked_register_write (gdbarch, sh64_cooked_register_write);
set_gdbarch_do_registers_info (gdbarch, sh64_do_registers_info);
set_gdbarch_frame_init_saved_regs (gdbarch, sh64_nofp_frame_init_saved_regs);