This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
Re: [patch/rfc;rfa:sh] gdbarch_register_read() -> gdbarch_pseudo_register_read()
- From: Elena Zannoni <ezannoni at redhat dot com>
- To: Andrew Cagney <ac131313 at ges dot redhat dot com>
- Cc: gdb-patches at sources dot redhat dot com
- Date: Fri, 2 Aug 2002 09:47:15 -0400
- Subject: Re: [patch/rfc;rfa:sh] gdbarch_register_read() -> gdbarch_pseudo_register_read()
- References: <3D46A03D.8090003@ges.redhat.com>
Andrew Cagney writes:
> Hello,
>
> This revises my earlier patch that replaced gdbarch_register_read() with
> regarch_cooked_register_read().
>
> Reviewing the doco discussion, think it is clear that the term
> ``pseudo'' is pretty entrenched in GDB. Even the presence of the word
> triggers certain assumptions :-) The change makes use of this.
>
> The attached patch replaces the function:
>
> void gdbarch_register_read (int regnum, char *buf);
> with
> void gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct
> regcache *regcache, int regnum, void *buf);
>
> It is called by (well will be once I add it) regcache_cooked_read() to
> map a cooked register in the range [NUM_REGS .. NUM_REGS +
> NUM_PSEUDO_REGS) (which are often refered to as pseudo registers) onto
> raw registers and/or memory. (Remember, cooked registers in the range
> [0 .. NUM_REGS) are 1:1 mapped onto raw registers.)
>
> Ditto for the write side.
>
> I'm also revising my WIP doco.
>
> For the SH, I've made use of this tightend specification (it doesn't get
> called for raw registers). Ok?
>
Sweet, some more cleanups. Ok, seems reasonable.
Elena
> I'll look to commit in a few days.
>
> Andrew
> 2002-07-30 Andrew Cagney <cagney@redhat.com>
>
> * gdbarch.sh (pseudo_register_read, pseudo_register_write):
> Replace the architecture methods register_read and register_write.
> * gdbarch.h, gdbarch.c: Regenerate.
> * regcache.c (init_regcache_descr): Update.
> (read_register_gen): Update.
> (write_register_gen): Update.
> (supply_register): Update comment.
>
> * sh-tdep.c (sh_gdbarch_init): Update.
> (sh_pseudo_register_read, sh64_pseudo_register_read): Add
> `regcache' and `gdbarch' parameters. Make `buffer' a void
> pointer. Update code.
> (sh_pseudo_register_write, sh64_pseudo_register_write): Add
> `regcache' and `gdbarch' parameters. Make `buffer' a constant
> void pointer. Update code.
> (sh64_register_write): Delete.
> (sh4_register_read): Delete.
> (sh64_register_read): Delete.
> (sh4_register_write): Delete.
> (sh_sh4_register_convert_to_raw): Make `from' parameter a constant
> void pointer, `to' parameter a void pointer.
> (sh_sh64_register_convert_to_raw): Ditto.
>
> 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 30 Jul 2002 13:48:46 -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:pseudo_register_read:struct regcache *regcache, int cookednum, void *buf:regcache, cookednum, buf:
> +M:::void:pseudo_register_write:struct regcache *regcache, int cookednum, const void *buf:regcache, cookednum, 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.43
> diff -u -r1.43 regcache.c
> --- regcache.c 29 Jul 2002 19:54:42 -0000 1.43
> +++ regcache.c 30 Jul 2002 13:48:46 -0000
> @@ -143,8 +143,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_pseudo_register_read_p (gdbarch)
> + && !gdbarch_pseudo_register_write_p (gdbarch))
> return init_legacy_regcache_descr (gdbarch);
>
> descr = XMALLOC (struct regcache_descr);
> @@ -724,7 +724,8 @@
> if (regnum < current_regcache->descr->nr_raw_registers)
> regcache_raw_read (current_regcache, regnum, buf);
> else
> - gdbarch_register_read (current_gdbarch, regnum, buf);
> + gdbarch_pseudo_register_read (current_gdbarch, current_regcache,
> + regnum, buf);
> }
>
>
> @@ -838,7 +839,8 @@
> if (regnum < current_regcache->descr->nr_raw_registers)
> regcache_raw_write (current_regcache, regnum, buf);
> else
> - gdbarch_register_write (current_gdbarch, regnum, buf);
> + gdbarch_pseudo_register_write (current_gdbarch, current_regcache,
> + regnum, buf);
> }
>
> /* Copy INLEN bytes of consecutive data from memory at MYADDR
> @@ -1024,7 +1026,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_pseudo_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.68
> diff -u -r1.68 sh-tdep.c
> --- sh-tdep.c 29 Jul 2002 16:34:06 -0000 1.68
> +++ sh-tdep.c 30 Jul 2002 13:48:48 -0000
> @@ -3331,7 +3331,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);
>
> @@ -3347,7 +3347,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);
>
> @@ -3371,11 +3371,12 @@
> }
>
> void
> -sh_pseudo_register_read (int reg_nr, char *buffer)
> +sh_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
> + int reg_nr, void *buffer)
> {
> int base_regnum, portion;
> char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
> - struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
> + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
>
> if (reg_nr >= tdep->DR0_REGNUM
> && reg_nr <= tdep->DR_LAST_REGNUM)
> @@ -3385,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. */
> @@ -3400,30 +3401,21 @@
>
> /* 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,
> - buffer + REGISTER_RAW_SIZE (base_regnum) * portion);
> + regcache_raw_read (regcache, base_regnum + portion,
> + ((char *) buffer
> + + REGISTER_RAW_SIZE (base_regnum) * portion));
> }
> }
>
> static void
> -sh4_register_read (struct gdbarch *gdbarch, int reg_nr, char *buffer)
> -{
> - if (reg_nr >= 0 && reg_nr < gdbarch_tdep (current_gdbarch)->DR0_REGNUM)
> - /* It is a regular register. */
> - 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);
> -}
> -
> -static void
> -sh64_pseudo_register_read (int reg_nr, char *buffer)
> +sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
> + int reg_nr, void *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);
> + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
>
> if (reg_nr >= tdep->DR0_REGNUM
> && reg_nr <= tdep->DR_LAST_REGNUM)
> @@ -3434,7 +3426,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));
>
> @@ -3453,8 +3445,8 @@
> /* 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,
> - (buffer
> + regcache_raw_read (regcache, base_regnum + portion,
> + ((char *) buffer
> + REGISTER_RAW_SIZE (base_regnum) * portion));
> }
>
> @@ -3467,8 +3459,8 @@
> /* 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,
> - (buffer
> + regcache_raw_read (regcache, base_regnum + portion,
> + ((char *) buffer
> + REGISTER_RAW_SIZE (base_regnum) * portion));
> }
>
> @@ -3479,7 +3471,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????*/
> @@ -3493,7 +3485,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
> @@ -3504,7 +3496,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));
>
> @@ -3522,8 +3514,8 @@
> /* 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,
> - (buffer
> + regcache_raw_read (regcache, base_regnum + portion,
> + ((char *) buffer
> + REGISTER_RAW_SIZE (base_regnum) * portion));
> }
>
> @@ -3555,11 +3547,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. */
> @@ -3577,28 +3569,17 @@
>
> /* 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)
> -{
> -
> - if (reg_nr >= 0 && reg_nr < gdbarch_tdep (current_gdbarch)->DR0_REGNUM)
> - /* It is a regular register. */
> - 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);
> -}
> -
> void
> -sh_pseudo_register_write (int reg_nr, char *buffer)
> +sh_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
> + int reg_nr, const void *buffer)
> {
> int base_regnum, portion;
> char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
> - struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
> + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
>
> if (reg_nr >= tdep->DR0_REGNUM
> && reg_nr <= tdep->DR_LAST_REGNUM)
> @@ -3611,7 +3592,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));
> }
> @@ -3622,30 +3603,20 @@
>
> /* 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,
> - (buffer
> + regcache_raw_write (regcache, base_regnum + portion,
> + ((char *) buffer
> + REGISTER_RAW_SIZE (base_regnum) * portion));
> }
> }
>
> -static void
> -sh4_register_write (struct gdbarch *gdbarch, int reg_nr, char *buffer)
> -{
> - if (reg_nr >= 0 && reg_nr < gdbarch_tdep (current_gdbarch)->DR0_REGNUM)
> - /* It is a regular register. */
> - 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);
> -}
> -
> void
> -sh64_pseudo_register_write (int reg_nr, char *buffer)
> +sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
> + int reg_nr, const void *buffer)
> {
> int base_regnum, portion;
> int offset;
> char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
> - struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
> + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
>
> if (reg_nr >= tdep->DR0_REGNUM
> && reg_nr <= tdep->DR_LAST_REGNUM)
> @@ -3658,7 +3629,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));
> }
> @@ -3670,8 +3641,8 @@
>
> /* 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,
> - (buffer
> + regcache_raw_write (regcache, base_regnum + portion,
> + ((char *) buffer
> + REGISTER_RAW_SIZE (base_regnum) * portion));
> }
>
> @@ -3682,8 +3653,8 @@
>
> /* 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,
> - (buffer
> + regcache_raw_write (regcache, base_regnum + portion,
> + ((char *) buffer
> + REGISTER_RAW_SIZE (base_regnum) * portion));
> }
>
> @@ -3701,10 +3672,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
> @@ -3713,7 +3684,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
> @@ -3726,7 +3697,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));
> }
> @@ -3739,8 +3710,8 @@
>
> for (portion = 0; portion < 4; portion++)
> {
> - regcache_raw_write (current_regcache, base_regnum + portion,
> - (buffer
> + regcache_raw_write (regcache, base_regnum + portion,
> + ((char *) buffer
> + REGISTER_RAW_SIZE (base_regnum) * portion));
> }
> }
> @@ -3783,39 +3754,28 @@
> 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)
> -{
> - if (reg_nr >= 0 && reg_nr < gdbarch_tdep (current_gdbarch)->DR0_REGNUM)
> - /* It is a regular register. */
> - 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);
> -}
> -
> /* Floating point vector of 4 float registers. */
> static void
> do_fv_register_info (int fv_regnum)
> @@ -4448,8 +4408,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_pseudo_register_read (gdbarch, sh_pseudo_register_read);
> + set_gdbarch_pseudo_register_write (gdbarch, sh_pseudo_register_write);
> tdep->FPUL_REGNUM = 23;
> tdep->FPSCR_REGNUM = 24;
> tdep->FP_LAST_REGNUM = 40;
> @@ -4540,8 +4500,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_pseudo_register_read (gdbarch, sh64_pseudo_register_read);
> + set_gdbarch_pseudo_register_write (gdbarch, sh64_pseudo_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);