From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jim Blandy To: gdb-patches@sources.redhat.com Subject: RFA: rs6000: no more legacy regcache Date: Fri, 28 May 2004 18:51:00 -0000 Message-id: X-SW-Source: 2004-05/msg00769.html This causes no regressions on powerpc-unknown-linux-gnu, and fixes several failures in gdb.base/store.exp on powerpc-ibm-aix4.3.3.0. It allows powerpc-eabispe to run on the simulator at all. And I think it clears the way for removing the register offset stuff in rs6000-tdep.c. 2004-05-27 Jim Blandy * rs6000-tdep.c: Use the modern gdbarch methods for handling the register set, so our regcache isn't declared "legacy" and our E500 pseudoregister read and write functions aren't ignored. (rs6000_register_byte, rs6000_register_raw_size, rs6000_register_virtual_type, rs6000_register_convertible, rs6000_register_convert_to_virtual, rs6000_register_convert_to_raw): Deleted. (rs6000_register_type, rs6000_convert_register_p, rs6000_register_to_value, rs6000_value_to_register): New functions. (rs6000_gdbarch_init): Don't register gdbarch_deprecated_register_size, gdbarch_deprecated_register_bytes, gdbarch_deprecated_register_byte, gdbarch_deprecated_register_raw_size, gdbarch_deprecated_register_virtual_type, gdbarch_deprecated_register_convertible, gdbarch_deprecated_register_convert_to_virtual, or gdbarch_deprecated_register_convert_to_raw methods. Instead, register gdbarch_register_type, gdbarch_convert_register_p, gdbarch_register_to_value, and gdbarch_value_to_register methods. Index: gdb/rs6000-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/rs6000-tdep.c,v retrieving revision 1.208 diff -c -p -r1.208 rs6000-tdep.c *** gdb/rs6000-tdep.c 22 May 2004 06:03:26 -0000 1.208 --- gdb/rs6000-tdep.c 28 May 2004 02:02:11 -0000 *************** rs6000_register_name (int n) *** 1677,1709 **** return reg->name; } - /* Index within `registers' of the first byte of the space for - register N. */ - - static int - rs6000_register_byte (int n) - { - return gdbarch_tdep (current_gdbarch)->regoff[n]; - } - - /* Return the number of bytes of storage in the actual machine representation - for register N if that register is available, else return 0. */ - - static int - rs6000_register_raw_size (int n) - { - struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); - const struct reg *reg = tdep->regs + n; - return regsize (reg, tdep->wordsize); - } - /* Return the GDB type object for the "standard" data type of data in register N. */ static struct type * ! rs6000_register_virtual_type (int n) { ! struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); const struct reg *reg = tdep->regs + n; if (reg->fpr) --- 1677,1689 ---- return reg->name; } /* Return the GDB type object for the "standard" data type of data in register N. */ static struct type * ! rs6000_register_type (struct gdbarch *gdbarch, int n) { ! struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); const struct reg *reg = tdep->regs + n; if (reg->fpr) *************** rs6000_register_virtual_type (int n) *** 1733,1781 **** } } ! /* Return whether register N requires conversion when moving from raw format ! to virtual format. ! ! The register format for RS/6000 floating point registers is always double, we need a conversion if the memory format is float. */ static int ! rs6000_register_convertible (int n) { ! const struct reg *reg = gdbarch_tdep (current_gdbarch)->regs + n; ! return reg->fpr; } - /* Convert data from raw format for register N in buffer FROM - to virtual format with type TYPE in buffer TO. */ - static void ! rs6000_register_convert_to_virtual (int n, struct type *type, ! char *from, char *to) ! { ! if (TYPE_LENGTH (type) != DEPRECATED_REGISTER_RAW_SIZE (n)) ! { ! double val = deprecated_extract_floating (from, DEPRECATED_REGISTER_RAW_SIZE (n)); ! deprecated_store_floating (to, TYPE_LENGTH (type), val); ! } ! else ! memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (n)); ! } ! /* Convert data from virtual format with type TYPE in buffer FROM ! to raw format for register N in buffer TO. */ static void ! rs6000_register_convert_to_raw (struct type *type, int n, ! const char *from, char *to) { ! if (TYPE_LENGTH (type) != DEPRECATED_REGISTER_RAW_SIZE (n)) ! { ! double val = deprecated_extract_floating (from, TYPE_LENGTH (type)); ! deprecated_store_floating (to, DEPRECATED_REGISTER_RAW_SIZE (n), val); ! } ! else ! memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (n)); } static void --- 1713,1761 ---- } } ! /* The register format for RS/6000 floating point registers is always double, we need a conversion if the memory format is float. */ static int ! rs6000_convert_register_p (int regnum, struct type *type) { ! const struct reg *reg = gdbarch_tdep (current_gdbarch)->regs + regnum; ! ! return (reg->fpr ! && TYPE_CODE (type) == TYPE_CODE_FLT ! && TYPE_LENGTH (type) != TYPE_LENGTH (builtin_type_double)); } static void ! rs6000_register_to_value (struct frame_info *frame, ! int regnum, ! struct type *type, ! void *to) ! { ! const struct reg *reg = gdbarch_tdep (current_gdbarch)->regs + regnum; ! char from[MAX_REGISTER_SIZE]; ! ! gdb_assert (reg->fpr); ! gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT); ! get_frame_register (frame, regnum, from); ! convert_typed_floating (from, builtin_type_double, to, type); ! } static void ! rs6000_value_to_register (struct frame_info *frame, ! int regnum, ! struct type *type, ! const void *from) { ! const struct reg *reg = gdbarch_tdep (current_gdbarch)->regs + regnum; ! char to[MAX_REGISTER_SIZE]; ! ! gdb_assert (reg->fpr); ! gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT); ! ! convert_typed_floating (from, type, to, builtin_type_double); ! put_frame_register (frame, regnum, to); } static void *************** rs6000_gdbarch_init (struct gdbarch_info *** 2937,2947 **** set_gdbarch_num_regs (gdbarch, v->nregs); set_gdbarch_num_pseudo_regs (gdbarch, v->npregs); set_gdbarch_register_name (gdbarch, rs6000_register_name); ! set_gdbarch_deprecated_register_size (gdbarch, wordsize); ! set_gdbarch_deprecated_register_bytes (gdbarch, off); ! set_gdbarch_deprecated_register_byte (gdbarch, rs6000_register_byte); ! set_gdbarch_deprecated_register_raw_size (gdbarch, rs6000_register_raw_size); ! set_gdbarch_deprecated_register_virtual_type (gdbarch, rs6000_register_virtual_type); set_gdbarch_ptr_bit (gdbarch, wordsize * TARGET_CHAR_BIT); set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT); --- 2917,2923 ---- set_gdbarch_num_regs (gdbarch, v->nregs); set_gdbarch_num_pseudo_regs (gdbarch, v->npregs); set_gdbarch_register_name (gdbarch, rs6000_register_name); ! set_gdbarch_register_type (gdbarch, rs6000_register_type); set_gdbarch_ptr_bit (gdbarch, wordsize * TARGET_CHAR_BIT); set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT); *************** rs6000_gdbarch_init (struct gdbarch_info *** 2967,2975 **** 224. */ set_gdbarch_frame_red_zone_size (gdbarch, 224); ! set_gdbarch_deprecated_register_convertible (gdbarch, rs6000_register_convertible); ! set_gdbarch_deprecated_register_convert_to_virtual (gdbarch, rs6000_register_convert_to_virtual); ! set_gdbarch_deprecated_register_convert_to_raw (gdbarch, rs6000_register_convert_to_raw); set_gdbarch_stab_reg_to_regnum (gdbarch, rs6000_dwarf2_stab_reg_to_regnum); set_gdbarch_dwarf2_reg_to_regnum (gdbarch, rs6000_dwarf2_stab_reg_to_regnum); /* Note: kevinb/2002-04-12: I'm not convinced that rs6000_push_arguments() --- 2943,2952 ---- 224. */ set_gdbarch_frame_red_zone_size (gdbarch, 224); ! set_gdbarch_convert_register_p (gdbarch, rs6000_convert_register_p); ! set_gdbarch_register_to_value (gdbarch, rs6000_register_to_value); ! set_gdbarch_value_to_register (gdbarch, rs6000_value_to_register); ! set_gdbarch_stab_reg_to_regnum (gdbarch, rs6000_dwarf2_stab_reg_to_regnum); set_gdbarch_dwarf2_reg_to_regnum (gdbarch, rs6000_dwarf2_stab_reg_to_regnum); /* Note: kevinb/2002-04-12: I'm not convinced that rs6000_push_arguments()