2002-07-24 Andrew Cagney * 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);