diff options
69 files changed, 409 insertions, 364 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 155b52ec698..a4148302f02 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,25 @@ +2003-10-02 Andrew Cagney <cagney@redhat.com> + + * gdbarch.sh (DEPRECATED_REGISTER_RAW_SIZE): Rename + REGISTER_RAW_SIZE. + * gdbarch.h, gdbarch.c: Re-generate. + * aix-thread.c, alpha-tdep.h, arm-tdep.c, core-sol2.c: Update. + * cris-tdep.c, dve3900-rom.c, findvar.c, frame.c: Update. + * hppa-tdep.c, hppab-nat.c, hppah-nat.c, hppam3-nat.c: Update. + * hpux-thread.c, i386gnu-nat.c, ia64-aix-nat.c: Update. + * ia64-linux-nat.c, ia64-tdep.c, infcmd.c, infptrace.c: Update. + * infrun.c, irix5-nat.c, lynx-nat.c, mips-linux-tdep.c: Update. + * mips-nat.c, mips-tdep.c, mipsv4-nat.c, mn10300-tdep.c: Update. + * monitor.c, ns32k-tdep.c, ppc-linux-nat.c, regcache.c: Update. + * remote-e7000.c, remote-mips.c, remote-sim.c: Update. + * remote-vxmips.c, remote-vxsparc.c, remote.c: Update. + * rom68k-rom.c, rs6000-nat.c, rs6000-tdep.c, s390-tdep.c: Update. + * sh64-tdep.c, sparc-nat.c, sparc-tdep.c, stack.c: Update. + * target.c, tracepoint.c, v850-tdep.c, v850ice.c, valops.c: Update. + * vax-tdep.c, vax-tdep.h, x86-64-tdep.c, xstormy16-tdep.c: Update. + * config/m68k/tm-delta68.h, config/m68k/tm-vx68.h: Update. + * config/sparc/tm-sparc.h, config/sparc/tm-sparclynx.h: Update. + 2003-10-02 Jim Blandy <jimb@redhat.com> * dwarf2read.c (struct die_info): Doc fix. diff --git a/gdb/aix-thread.c b/gdb/aix-thread.c index da75f21dbd1..18ee0b1f0f5 100644 --- a/gdb/aix-thread.c +++ b/gdb/aix-thread.c @@ -852,7 +852,7 @@ pd_enable (void) return; /* Check application word size. */ - arch64 = REGISTER_RAW_SIZE (0) == 8; + arch64 = DEPRECATED_REGISTER_RAW_SIZE (0) == 8; /* Check whether the application is pthreaded. */ stub_name = NULL; @@ -1281,7 +1281,7 @@ fill_sprs64 (uint64_t *iar, uint64_t *msr, uint32_t *cr, they're not, then either GDB has been built incorrectly, or there's some other kind of internal error. To be really safe, we should check all of the sizes. */ - gdb_assert (sizeof (*iar) == REGISTER_RAW_SIZE (PC_REGNUM)); + gdb_assert (sizeof (*iar) == DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM)); if (register_cached (PC_REGNUM)) regcache_collect (PC_REGNUM, iar); @@ -1316,7 +1316,7 @@ fill_sprs32 (unsigned long *iar, unsigned long *msr, unsigned long *cr, built incorrectly. In order to make use of many of the header files in /usr/include/sys, GDB needs to be configured so that sizeof (long) == 4). */ - gdb_assert (sizeof (*iar) == REGISTER_RAW_SIZE (PC_REGNUM)); + gdb_assert (sizeof (*iar) == DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM)); if (register_cached (PC_REGNUM)) regcache_collect (PC_REGNUM, iar); diff --git a/gdb/alpha-tdep.h b/gdb/alpha-tdep.h index 9afe7be5f53..828a3c6b2f7 100644 --- a/gdb/alpha-tdep.h +++ b/gdb/alpha-tdep.h @@ -23,8 +23,9 @@ #define ALPHA_TDEP_H /* Say how long (ordinary) registers are. This is a piece of bogosity - used in push_word and a few other places; REGISTER_RAW_SIZE is the - real way to know how big a register is. */ + used in push_word and a few other places; + DEPRECATED_REGISTER_RAW_SIZE is the real way to know how big a + register is. */ #define ALPHA_REGISTER_SIZE 8 /* Number of machine registers. */ diff --git a/gdb/arm-tdep.c b/gdb/arm-tdep.c index 102c4bada18..12e4371d3b2 100644 --- a/gdb/arm-tdep.c +++ b/gdb/arm-tdep.c @@ -1103,7 +1103,7 @@ arm_make_sigtramp_cache (struct frame_info *next_frame) cache->framereg = ARM_SP_REGNUM; cache->prev_sp = read_memory_integer (cache->saved_regs[cache->framereg].addr, - REGISTER_RAW_SIZE (cache->framereg)); + DEPRECATED_REGISTER_RAW_SIZE (cache->framereg)); return cache; } diff --git a/gdb/config/m68k/tm-delta68.h b/gdb/config/m68k/tm-delta68.h index 97112a83f46..a360a785227 100644 --- a/gdb/config/m68k/tm-delta68.h +++ b/gdb/config/m68k/tm-delta68.h @@ -68,10 +68,10 @@ struct frame_info; #define DEPRECATED_STORE_RETURN_VALUE(TYPE,VALBUF) \ if (TYPE_CODE (TYPE) == TYPE_CODE_FLT) \ { \ - char raw_buf[REGISTER_RAW_SIZE (FP0_REGNUM)]; \ + char raw_buf[DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM)]; \ DEPRECATED_REGISTER_CONVERT_TO_RAW (TYPE, FP0_REGNUM, VALBUF, raw_buf); \ deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (FP0_REGNUM), \ - raw_buf, REGISTER_RAW_SIZE (FP0_REGNUM)); \ + raw_buf, DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM)); \ } \ else \ deprecated_write_register_bytes ((TYPE_CODE(TYPE) == TYPE_CODE_PTR ? 8 * 4 : 0), \ diff --git a/gdb/config/m68k/tm-vx68.h b/gdb/config/m68k/tm-vx68.h index 271eb7ef70e..ce1a8590e5c 100644 --- a/gdb/config/m68k/tm-vx68.h +++ b/gdb/config/m68k/tm-vx68.h @@ -78,5 +78,5 @@ /* Number of registers in a ptrace_getfpregs call. */ -#define VX_SIZE_FPREGS (8 * REGISTER_RAW_SIZE (FP0_REGNUM) \ +#define VX_SIZE_FPREGS (8 * DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM) \ + (3 * DEPRECATED_REGISTER_SIZE)) diff --git a/gdb/config/sparc/tm-sparc.h b/gdb/config/sparc/tm-sparc.h index 1567d0d518e..94e8d8c9eee 100644 --- a/gdb/config/sparc/tm-sparc.h +++ b/gdb/config/sparc/tm-sparc.h @@ -223,7 +223,7 @@ extern void sparc_print_extra_frame_info (struct frame_info *); address). Some vendors get it wrong. */ #define FRAME_SAVED_L0 0 -#define FRAME_SAVED_I0 (8 * REGISTER_RAW_SIZE (L0_REGNUM)) +#define FRAME_SAVED_I0 (8 * DEPRECATED_REGISTER_RAW_SIZE (L0_REGNUM)) #define FRAME_STRUCT_ARGS_ADDRESS(FI) (get_frame_base (FI)) diff --git a/gdb/config/sparc/tm-sparclynx.h b/gdb/config/sparc/tm-sparclynx.h index 3d196539beb..e4ea4d5223d 100644 --- a/gdb/config/sparc/tm-sparclynx.h +++ b/gdb/config/sparc/tm-sparclynx.h @@ -32,6 +32,6 @@ #undef FRAME_SAVED_L0 #define FRAME_SAVED_I0 0 -#define FRAME_SAVED_L0 (8 * REGISTER_RAW_SIZE (I0_REGNUM)) +#define FRAME_SAVED_L0 (8 * DEPRECATED_REGISTER_RAW_SIZE (I0_REGNUM)) #endif /* TM_SPARCLYNX_H */ diff --git a/gdb/core-sol2.c b/gdb/core-sol2.c index a3652333a16..456eebc8f62 100644 --- a/gdb/core-sol2.c +++ b/gdb/core-sol2.c @@ -98,7 +98,7 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which, /* The globals and output registers. */ memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (G1_REGNUM)], - &gregs->r_g1, 15 * REGISTER_RAW_SIZE (G1_REGNUM)); + &gregs->r_g1, 15 * DEPRECATED_REGISTER_RAW_SIZE (G1_REGNUM)); *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PS_REGNUM)] = gregs->r_ps; *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)] @@ -119,7 +119,7 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which, sp = *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (SP_REGNUM)]; if (0 != target_read_memory (sp, &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)], - 16 * REGISTER_RAW_SIZE (L0_REGNUM))) + 16 * DEPRECATED_REGISTER_RAW_SIZE (L0_REGNUM))) { warning ("couldn't read input and local registers from core file\n"); } diff --git a/gdb/cris-tdep.c b/gdb/cris-tdep.c index 846cef8cc6e..adb2e746017 100644 --- a/gdb/cris-tdep.c +++ b/gdb/cris-tdep.c @@ -1224,7 +1224,7 @@ cris_init_extra_frame_info (int fromleaf, struct frame_info *fi) /* SRP was saved on the stack; non-leaf function. */ get_frame_extra_info (fi)->return_pc = read_memory_integer (deprecated_get_frame_saved_regs (fi)[SRP_REGNUM], - REGISTER_RAW_SIZE (SRP_REGNUM)); + DEPRECATED_REGISTER_RAW_SIZE (SRP_REGNUM)); } else { @@ -4184,8 +4184,9 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_register_name (gdbarch, cris_register_name); - /* Length of ordinary registers used in push_word and a few other places. - REGISTER_RAW_SIZE is the real way to know how big a register is. */ + /* Length of ordinary registers used in push_word and a few other + places. DEPRECATED_REGISTER_RAW_SIZE is the real way to know how + big a register is. */ set_gdbarch_deprecated_register_size (gdbarch, 4); /* NEW */ @@ -4239,7 +4240,7 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) /* The length of the registers in the actual machine representation. */ set_gdbarch_deprecated_register_raw_size (gdbarch, cris_register_size); - /* The largest value REGISTER_RAW_SIZE can have. */ + /* The largest value DEPRECATED_REGISTER_RAW_SIZE can have. */ set_gdbarch_deprecated_max_register_raw_size (gdbarch, 32); /* The length of the registers in the program's representation. */ diff --git a/gdb/doc/ChangeLog b/gdb/doc/ChangeLog index bdc1b3cad92..d3a2cca5f13 100644 --- a/gdb/doc/ChangeLog +++ b/gdb/doc/ChangeLog @@ -1,6 +1,12 @@ -2003-09-30 Andrew Cagney <cagney@redhat.com> +2003-10-02 Andrew Cagney <cagney@redhat.com> * gdbint.texinfo (Target Architecture Definition): Rename + REGISTER_RAW_SIZE to DEPRECATED_REGISTER_RAW_SIZE. + * gdb.texinfo (Packets, Stop Reply Packets): Ditto. + * gdbint.texinfo (Target Architecture Definition): Rename + +2003-09-30 Andrew Cagney <cagney@redhat.com> + REGISTER_VIRTUAL_SIZE to DEPRECATED_REGISTER_VIRTUAL_SIZE. (Target Architecture Definition): diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo index cf69fd3e741..4700a0017b3 100644 --- a/gdb/doc/gdb.texinfo +++ b/gdb/doc/gdb.texinfo @@ -19517,9 +19517,9 @@ Reply: Each byte of register data is described by two hex digits. The bytes with the register are transmitted in target byte order. The size of each register and their position within the @samp{g} @var{packet} are -determined by the @value{GDBN} internal macros @var{REGISTER_RAW_SIZE} -and @var{REGISTER_NAME} macros. The specification of several standard -@code{g} packets is specified below. +determined by the @value{GDBN} internal macros +@var{DEPRECATED_REGISTER_RAW_SIZE} and @var{REGISTER_NAME} macros. The +specification of several standard @code{g} packets is specified below. @item E@var{NN} for an error. @end table @@ -19971,12 +19971,13 @@ conventions is used. @var{AA} = two hex digit signal number; @var{n...} = register number (hex), @var{r...} = target byte ordered register contents, size defined -by @code{REGISTER_RAW_SIZE}; @var{n...} = @samp{thread}, @var{r...} = -thread process ID, this is a hex integer; @var{n...} = (@samp{watch} | -@samp{rwatch} | @samp{awatch}, @var{r...} = data address, this is a hex -integer; @var{n...} = other string not starting with valid hex digit. -@value{GDBN} should ignore this @var{n...}, @var{r...} pair and go on -to the next. This way we can extend the protocol. +by @code{DEPRECATED_REGISTER_RAW_SIZE}; @var{n...} = @samp{thread}, +@var{r...} = thread process ID, this is a hex integer; @var{n...} = +(@samp{watch} | @samp{rwatch} | @samp{awatch}, @var{r...} = data +address, this is a hex integer; @var{n...} = other string not starting +with valid hex digit. @value{GDBN} should ignore this @var{n...}, +@var{r...} pair and go on to the next. This way we can extend the +protocol. @item W@var{AA} diff --git a/gdb/doc/gdbint.texinfo b/gdb/doc/gdbint.texinfo index 8878d514f69..8c4b5bc32fe 100644 --- a/gdb/doc/gdbint.texinfo +++ b/gdb/doc/gdbint.texinfo @@ -38,7 +38,7 @@ Free Documentation License''. @page @tex \def\$#1${{#1}} % Kluge: collect RCS revision info without $...$ -\xdef\manvers{\$Revision: 1.171 $} % For use in headers, footers too +\xdef\manvers{\$Revision: 1.172 $} % For use in headers, footers too {\parskip=0pt \hfill Cygnus Solutions\par \hfill \manvers\par @@ -2766,7 +2766,7 @@ You should not use @code{REGISTER_CONVERT_TO_VIRTUAL} for a register unless this macro returns a non-zero value for that register. @end deftypefn -@deftypefn {Target Macro} int REGISTER_RAW_SIZE (int @var{reg}) +@deftypefn {Target Macro} int DEPRECATED_REGISTER_RAW_SIZE (int @var{reg}) The size of register number @var{reg}'s raw value. This is the number of bytes the register will occupy in @code{registers}, or in a @value{GDBN} remote protocol packet. @@ -3505,8 +3505,8 @@ Convert the raw contents of register @var{regnum} into a value of type @var{type}. @xref{Target Architecture Definition, , Using Different Register and Memory Data Representations}. -@item REGISTER_RAW_SIZE (@var{reg}) -@findex REGISTER_RAW_SIZE +@item DEPRECATED_REGISTER_RAW_SIZE (@var{reg}) +@findex DEPRECATED_REGISTER_RAW_SIZE Return the raw size of @var{reg}; defaults to the size of the register's virtual type. @xref{Target Architecture Definition, , Raw and Virtual Register Representations}. diff --git a/gdb/dve3900-rom.c b/gdb/dve3900-rom.c index 02a273c10e1..665179ff327 100644 --- a/gdb/dve3900-rom.c +++ b/gdb/dve3900-rom.c @@ -471,7 +471,7 @@ fetch_bitmapped_register (int regno, struct bit_field *bf) /* supply register stores in target byte order, so swap here */ - store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), val); + store_unsigned_integer (regbuf, DEPRECATED_REGISTER_RAW_SIZE (regno), val); supply_register (regno, regbuf); } diff --git a/gdb/findvar.c b/gdb/findvar.c index 1e83942c350..34b4a5b50e6 100644 --- a/gdb/findvar.c +++ b/gdb/findvar.c @@ -289,15 +289,15 @@ value_of_register (int regnum, struct frame_info *frame) DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum, register_type (current_gdbarch, regnum), raw_buffer, VALUE_CONTENTS_RAW (reg_val)); } - else if (REGISTER_RAW_SIZE (regnum) == DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum)) + else if (DEPRECATED_REGISTER_RAW_SIZE (regnum) == DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum)) memcpy (VALUE_CONTENTS_RAW (reg_val), raw_buffer, - REGISTER_RAW_SIZE (regnum)); + DEPRECATED_REGISTER_RAW_SIZE (regnum)); else internal_error (__FILE__, __LINE__, "Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size", REGISTER_NAME (regnum), regnum, - REGISTER_RAW_SIZE (regnum), + DEPRECATED_REGISTER_RAW_SIZE (regnum), DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum)); VALUE_LVAL (reg_val) = lval; VALUE_ADDRESS (reg_val) = addr; @@ -647,7 +647,7 @@ value_from_register (struct type *type, int regnum, struct frame_info *frame) /* Copy all of the data out, whereever it may be. */ for (local_regnum = regnum, value_bytes_copied = 0; value_bytes_copied < len; - (value_bytes_copied += REGISTER_RAW_SIZE (local_regnum), + (value_bytes_copied += DEPRECATED_REGISTER_RAW_SIZE (local_regnum), ++local_regnum)) { int realnum; @@ -713,9 +713,9 @@ value_from_register (struct type *type, int regnum, struct frame_info *frame) some fiddling with the last register copied here for little endian machines. */ if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG - && len < REGISTER_RAW_SIZE (regnum)) + && len < DEPRECATED_REGISTER_RAW_SIZE (regnum)) /* Big-endian, and we want less than full size. */ - VALUE_OFFSET (v) = REGISTER_RAW_SIZE (regnum) - len; + VALUE_OFFSET (v) = DEPRECATED_REGISTER_RAW_SIZE (regnum) - len; else VALUE_OFFSET (v) = 0; memcpy (VALUE_CONTENTS_RAW (v), value_bytes + VALUE_OFFSET (v), len); diff --git a/gdb/frame.c b/gdb/frame.c index 02daf543a20..e91c52abcde 100644 --- a/gdb/frame.c +++ b/gdb/frame.c @@ -703,7 +703,8 @@ put_frame_register (struct frame_info *frame, int regnum, const void *buf) /* frame_register_read () Find and return the value of REGNUM for the specified stack frame. - The number of bytes copied is REGISTER_RAW_SIZE (REGNUM). + The number of bytes copied is DEPRECATED_REGISTER_RAW_SIZE + (REGNUM). Returns 0 if the register value could not be found. */ @@ -966,7 +967,7 @@ legacy_saved_regs_prev_register (struct frame_info *next_frame, if (bufferp != NULL) /* NOTE: cagney/2003-05-09: In-lined store_address with it's body - store_unsigned_integer. */ - store_unsigned_integer (bufferp, REGISTER_RAW_SIZE (regnum), + store_unsigned_integer (bufferp, DEPRECATED_REGISTER_RAW_SIZE (regnum), deprecated_get_frame_saved_regs (frame)[regnum]); } else @@ -993,15 +994,15 @@ legacy_saved_regs_prev_register (struct frame_info *next_frame, if (regs[regnum] == NULL) { regs[regnum] - = frame_obstack_zalloc (REGISTER_RAW_SIZE (regnum)); + = frame_obstack_zalloc (DEPRECATED_REGISTER_RAW_SIZE (regnum)); read_memory (deprecated_get_frame_saved_regs (frame)[regnum], regs[regnum], - REGISTER_RAW_SIZE (regnum)); + DEPRECATED_REGISTER_RAW_SIZE (regnum)); } - memcpy (bufferp, regs[regnum], REGISTER_RAW_SIZE (regnum)); + memcpy (bufferp, regs[regnum], DEPRECATED_REGISTER_RAW_SIZE (regnum)); #else /* Read the value in from memory. */ read_memory (deprecated_get_frame_saved_regs (frame)[regnum], bufferp, - REGISTER_RAW_SIZE (regnum)); + DEPRECATED_REGISTER_RAW_SIZE (regnum)); #endif } } @@ -1109,7 +1110,7 @@ deprecated_generic_get_saved_register (char *raw_buffer, int *optimized, /* NOTE: cagney/2003-05-09: In-line store_address with it's body - store_unsigned_integer. */ store_unsigned_integer (raw_buffer, - REGISTER_RAW_SIZE (regnum), + DEPRECATED_REGISTER_RAW_SIZE (regnum), deprecated_get_frame_saved_regs (frame)[regnum]); } else @@ -1118,7 +1119,7 @@ deprecated_generic_get_saved_register (char *raw_buffer, int *optimized, *addrp = deprecated_get_frame_saved_regs (frame)[regnum]; if (raw_buffer) read_memory (deprecated_get_frame_saved_regs (frame)[regnum], raw_buffer, - REGISTER_RAW_SIZE (regnum)); + DEPRECATED_REGISTER_RAW_SIZE (regnum)); } return; } diff --git a/gdb/gdbarch.c b/gdb/gdbarch.c index b0be6abf928..28449180999 100644 --- a/gdb/gdbarch.c +++ b/gdb/gdbarch.c @@ -1524,6 +1524,25 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) (long) current_gdbarch->deprecated_register_convert_to_virtual /*DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL ()*/); #endif +#ifdef DEPRECATED_REGISTER_RAW_SIZE_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_REGISTER_RAW_SIZE_P()", + XSTRING (DEPRECATED_REGISTER_RAW_SIZE_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_REGISTER_RAW_SIZE_P() = %d\n", + DEPRECATED_REGISTER_RAW_SIZE_P ()); +#endif +#ifdef DEPRECATED_REGISTER_RAW_SIZE + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_REGISTER_RAW_SIZE(reg_nr)", + XSTRING (DEPRECATED_REGISTER_RAW_SIZE (reg_nr))); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_REGISTER_RAW_SIZE = <0x%08lx>\n", + (long) current_gdbarch->deprecated_register_raw_size + /*DEPRECATED_REGISTER_RAW_SIZE ()*/); +#endif #ifdef DEPRECATED_REGISTER_SIZE fprintf_unfiltered (file, "gdbarch_dump: DEPRECATED_REGISTER_SIZE # %s\n", @@ -2089,25 +2108,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) (long) current_gdbarch->register_name /*REGISTER_NAME ()*/); #endif -#ifdef REGISTER_RAW_SIZE_P - fprintf_unfiltered (file, - "gdbarch_dump: %s # %s\n", - "REGISTER_RAW_SIZE_P()", - XSTRING (REGISTER_RAW_SIZE_P ())); - fprintf_unfiltered (file, - "gdbarch_dump: REGISTER_RAW_SIZE_P() = %d\n", - REGISTER_RAW_SIZE_P ()); -#endif -#ifdef REGISTER_RAW_SIZE - fprintf_unfiltered (file, - "gdbarch_dump: %s # %s\n", - "REGISTER_RAW_SIZE(reg_nr)", - XSTRING (REGISTER_RAW_SIZE (reg_nr))); - fprintf_unfiltered (file, - "gdbarch_dump: REGISTER_RAW_SIZE = <0x%08lx>\n", - (long) current_gdbarch->deprecated_register_raw_size - /*REGISTER_RAW_SIZE ()*/); -#endif #ifdef REGISTER_SIM_REGNO fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", diff --git a/gdb/gdbarch.h b/gdb/gdbarch.h index 82e5d76f794..0e480a08376 100644 --- a/gdb/gdbarch.h +++ b/gdb/gdbarch.h @@ -539,29 +539,29 @@ extern void set_gdbarch_deprecated_register_byte (struct gdbarch *gdbarch, gdbar DEPRECATED_REGISTER_RAW_SIZE can be deleted. See: maint print registers. */ -#if defined (REGISTER_RAW_SIZE) -/* Legacy for systems yet to multi-arch REGISTER_RAW_SIZE */ -#if !defined (REGISTER_RAW_SIZE_P) -#define REGISTER_RAW_SIZE_P() (1) +#if defined (DEPRECATED_REGISTER_RAW_SIZE) +/* Legacy for systems yet to multi-arch DEPRECATED_REGISTER_RAW_SIZE */ +#if !defined (DEPRECATED_REGISTER_RAW_SIZE_P) +#define DEPRECATED_REGISTER_RAW_SIZE_P() (1) #endif #endif extern int gdbarch_deprecated_register_raw_size_p (struct gdbarch *gdbarch); -#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_RAW_SIZE_P) -#error "Non multi-arch definition of REGISTER_RAW_SIZE" +#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_REGISTER_RAW_SIZE_P) +#error "Non multi-arch definition of DEPRECATED_REGISTER_RAW_SIZE" #endif -#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_RAW_SIZE_P) -#define REGISTER_RAW_SIZE_P() (gdbarch_deprecated_register_raw_size_p (current_gdbarch)) +#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_REGISTER_RAW_SIZE_P) +#define DEPRECATED_REGISTER_RAW_SIZE_P() (gdbarch_deprecated_register_raw_size_p (current_gdbarch)) #endif typedef int (gdbarch_deprecated_register_raw_size_ftype) (int reg_nr); extern int gdbarch_deprecated_register_raw_size (struct gdbarch *gdbarch, int reg_nr); extern void set_gdbarch_deprecated_register_raw_size (struct gdbarch *gdbarch, gdbarch_deprecated_register_raw_size_ftype *deprecated_register_raw_size); -#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_RAW_SIZE) -#error "Non multi-arch definition of REGISTER_RAW_SIZE" +#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_REGISTER_RAW_SIZE) +#error "Non multi-arch definition of DEPRECATED_REGISTER_RAW_SIZE" #endif -#if !defined (REGISTER_RAW_SIZE) -#define REGISTER_RAW_SIZE(reg_nr) (gdbarch_deprecated_register_raw_size (current_gdbarch, reg_nr)) +#if !defined (DEPRECATED_REGISTER_RAW_SIZE) +#define DEPRECATED_REGISTER_RAW_SIZE(reg_nr) (gdbarch_deprecated_register_raw_size (current_gdbarch, reg_nr)) #endif /* If all registers have identical raw and virtual sizes and those diff --git a/gdb/gdbarch.sh b/gdb/gdbarch.sh index b9b0298659b..b537eabd7d6 100755 --- a/gdb/gdbarch.sh +++ b/gdb/gdbarch.sh @@ -486,7 +486,7 @@ F::DEPRECATED_REGISTER_BYTE:int:deprecated_register_byte:int reg_nr:reg_nr::gene # sizes agree with the value computed from REGISTER_TYPE, # DEPRECATED_REGISTER_RAW_SIZE can be deleted. See: maint print # registers. -F:2:REGISTER_RAW_SIZE:int:deprecated_register_raw_size:int reg_nr:reg_nr::generic_register_size:generic_register_size +F:2:DEPRECATED_REGISTER_RAW_SIZE:int:deprecated_register_raw_size:int reg_nr:reg_nr::generic_register_size:generic_register_size # If all registers have identical raw and virtual sizes and those # sizes agree with the value computed from REGISTER_TYPE, # DEPRECATED_REGISTER_VIRTUAL_SIZE can be deleted. See: maint print diff --git a/gdb/hppa-tdep.c b/gdb/hppa-tdep.c index fda327f56a8..0a70d89c037 100644 --- a/gdb/hppa-tdep.c +++ b/gdb/hppa-tdep.c @@ -2983,7 +2983,7 @@ pa_print_fp_reg (int i) frame_register_read (deprecated_selected_frame, i, raw_buffer); /* Put it in the buffer. No conversions are ever necessary. */ - memcpy (virtual_buffer, raw_buffer, REGISTER_RAW_SIZE (i)); + memcpy (virtual_buffer, raw_buffer, DEPRECATED_REGISTER_RAW_SIZE (i)); fputs_filtered (REGISTER_NAME (i), gdb_stdout); print_spaces_filtered (8 - strlen (REGISTER_NAME (i)), gdb_stdout); @@ -3001,8 +3001,8 @@ pa_print_fp_reg (int i) frame_register_read (deprecated_selected_frame, i + 1, raw_buffer); /* Copy it into the appropriate part of the virtual buffer. */ - memcpy (virtual_buffer + REGISTER_RAW_SIZE (i), raw_buffer, - REGISTER_RAW_SIZE (i)); + memcpy (virtual_buffer + DEPRECATED_REGISTER_RAW_SIZE (i), raw_buffer, + DEPRECATED_REGISTER_RAW_SIZE (i)); /* Dump it as a double. */ fputs_filtered (REGISTER_NAME (i), gdb_stdout); @@ -3029,7 +3029,7 @@ pa_strcat_fp_reg (int i, struct ui_file *stream, enum precision_type precision) frame_register_read (deprecated_selected_frame, i, raw_buffer); /* Put it in the buffer. No conversions are ever necessary. */ - memcpy (virtual_buffer, raw_buffer, REGISTER_RAW_SIZE (i)); + memcpy (virtual_buffer, raw_buffer, DEPRECATED_REGISTER_RAW_SIZE (i)); if (precision == double_precision && (i % 2) == 0) { @@ -3040,7 +3040,8 @@ pa_strcat_fp_reg (int i, struct ui_file *stream, enum precision_type precision) frame_register_read (deprecated_selected_frame, i + 1, raw_buf); /* Copy it into the appropriate part of the virtual buffer. */ - memcpy (virtual_buffer + REGISTER_RAW_SIZE (i), raw_buf, REGISTER_RAW_SIZE (i)); + memcpy (virtual_buffer + DEPRECATED_REGISTER_RAW_SIZE (i), raw_buf, + DEPRECATED_REGISTER_RAW_SIZE (i)); val_print (builtin_type_double, virtual_buffer, 0, 0, stream, 0, 1, 0, Val_pretty_default); diff --git a/gdb/hppab-nat.c b/gdb/hppab-nat.c index cbb481e82a3..416db66a2bc 100644 --- a/gdb/hppab-nat.c +++ b/gdb/hppab-nat.c @@ -64,7 +64,7 @@ fetch_register (int regno) offset = U_REGS_OFFSET; regaddr = register_addr (regno, offset); - for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int)) + for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (int)) { errno = 0; *(int *) &buf[i] = ptrace (PT_RUREGS, PIDGET (inferior_ptid), @@ -130,7 +130,7 @@ store_inferior_registers (int regno) } } else - for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int)) + for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (int)) { errno = 0; ptrace (PT_WUREGS, PIDGET (inferior_ptid), diff --git a/gdb/hppah-nat.c b/gdb/hppah-nat.c index 28ec350f170..ea4015a8d32 100644 --- a/gdb/hppah-nat.c +++ b/gdb/hppah-nat.c @@ -98,7 +98,7 @@ store_inferior_registers (int regno) return; offset = 0; - len = REGISTER_RAW_SIZE (regno); + len = DEPRECATED_REGISTER_RAW_SIZE (regno); /* Requests for register zero actually want the save_state's ss_flags member. As RM says: "Oh, what a hack!" */ @@ -109,10 +109,11 @@ store_inferior_registers (int regno) len = sizeof (ss.ss_flags); /* Note that ss_flags is always an int, no matter what - REGISTER_RAW_SIZE(0) says. Assuming all HP-UX PA machines - are big-endian, put it at the least significant end of the - value, and zap the rest of the buffer. */ - offset = REGISTER_RAW_SIZE (0) - len; + DEPRECATED_REGISTER_RAW_SIZE(0) says. Assuming all HP-UX + PA machines are big-endian, put it at the least + significant end of the value, and zap the rest of the + buffer. */ + offset = DEPRECATED_REGISTER_RAW_SIZE (0) - len; } /* Floating-point registers come from the ss_fpblock area. */ @@ -215,7 +216,7 @@ fetch_register (int regno) int i; offset = 0; - len = REGISTER_RAW_SIZE (regno); + len = DEPRECATED_REGISTER_RAW_SIZE (regno); /* Requests for register zero actually want the save_state's ss_flags member. As RM says: "Oh, what a hack!" */ @@ -226,10 +227,10 @@ fetch_register (int regno) len = sizeof (ss.ss_flags); /* Note that ss_flags is always an int, no matter what - REGISTER_RAW_SIZE(0) says. Assuming all HP-UX PA machines - are big-endian, put it at the least significant end of the - value, and zap the rest of the buffer. */ - offset = REGISTER_RAW_SIZE (0) - len; + DEPRECATED_REGISTER_RAW_SIZE(0) says. Assuming all HP-UX PA + machines are big-endian, put it at the least significant end + of the value, and zap the rest of the buffer. */ + offset = DEPRECATED_REGISTER_RAW_SIZE (0) - len; memset (buf, 0, sizeof (buf)); } diff --git a/gdb/hppam3-nat.c b/gdb/hppam3-nat.c index a89fae99c8a..cbee288c778 100644 --- a/gdb/hppam3-nat.c +++ b/gdb/hppam3-nat.c @@ -116,13 +116,13 @@ store_inferior_registers (int regno) if (regno > 0 && regno < NUM_REGS) { memcpy (&state[regno], &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)], - REGISTER_RAW_SIZE (regno)); + DEPRECATED_REGISTER_RAW_SIZE (regno)); } else { for (index = 0; index < NUM_REGS; index++) memcpy (&state[index], &deprecated_registers[DEPRECATED_REGISTER_BYTE (index)], - REGISTER_RAW_SIZE (index)); + DEPRECATED_REGISTER_RAW_SIZE (index)); /* state[index] = deprecated_registers[DEPRECATED_REGISTER_BYTE (index)]; */ } diff --git a/gdb/hpux-thread.c b/gdb/hpux-thread.c index 6136421217d..242d3a39a09 100644 --- a/gdb/hpux-thread.c +++ b/gdb/hpux-thread.c @@ -291,13 +291,13 @@ hpux_thread_fetch_registers (int regno) if (regno == FLAGS_REGNUM) /* Flags must be 0 to avoid bogus value for SS_INSYSCALL */ - memset (buf, '\000', REGISTER_RAW_SIZE (regno)); + memset (buf, '\000', DEPRECATED_REGISTER_RAW_SIZE (regno)); else if (regno == SP_REGNUM) store_unsigned_integer (buf, sizeof sp, sp); else if (regno == PC_REGNUM) - read_memory (sp - 20, buf, REGISTER_RAW_SIZE (regno)); + read_memory (sp - 20, buf, DEPRECATED_REGISTER_RAW_SIZE (regno)); else - read_memory (sp + regmap[regno], buf, REGISTER_RAW_SIZE (regno)); + read_memory (sp + regmap[regno], buf, DEPRECATED_REGISTER_RAW_SIZE (regno)); supply_register (regno, buf); } @@ -357,19 +357,19 @@ hpux_thread_store_registers (int regno) { write_memory ((CORE_ADDR) & tcb_ptr->static_ctx.sp, &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)], - REGISTER_RAW_SIZE (regno)); + DEPRECATED_REGISTER_RAW_SIZE (regno)); tcb_ptr->static_ctx.sp = (cma__t_hppa_regs *) (extract_unsigned_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)], - REGISTER_RAW_SIZE (regno)) + 160); + DEPRECATED_REGISTER_RAW_SIZE (regno)) + 160); } else if (regno == PC_REGNUM) write_memory (sp - 20, &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)], - REGISTER_RAW_SIZE (regno)); + DEPRECATED_REGISTER_RAW_SIZE (regno)); else write_memory (sp + regmap[regno], &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)], - REGISTER_RAW_SIZE (regno)); + DEPRECATED_REGISTER_RAW_SIZE (regno)); } } diff --git a/gdb/i386gnu-nat.c b/gdb/i386gnu-nat.c index dd9e32481dc..7533f0965d5 100644 --- a/gdb/i386gnu-nat.c +++ b/gdb/i386gnu-nat.c @@ -242,7 +242,7 @@ gnu_store_registers (int regno) if ((thread->fetched_regs & (1 << check_regno)) && memcpy (REG_ADDR (&old_state, check_regno), REG_ADDR (state, check_regno), - REGISTER_RAW_SIZE (check_regno))) + DEPRECATED_REGISTER_RAW_SIZE (check_regno))) /* Register CHECK_REGNO has changed! Ack! */ { warning ("Register %s changed after the thread was aborted", @@ -257,7 +257,7 @@ gnu_store_registers (int regno) #define fill(state, regno) \ memcpy (REG_ADDR(state, regno), &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)], \ - REGISTER_RAW_SIZE (regno)) + DEPRECATED_REGISTER_RAW_SIZE (regno)) if (regno == -1) { diff --git a/gdb/ia64-aix-nat.c b/gdb/ia64-aix-nat.c index ee3dc16811b..61f34e1e34d 100644 --- a/gdb/ia64-aix-nat.c +++ b/gdb/ia64-aix-nat.c @@ -87,7 +87,7 @@ fill_gregset (prgregset_t *gregsetp, int regno) #define COPY_REG(_fld_,_regi_) \ if ((regno == -1) || regno == _regi_) \ memcpy (&(gregsetp->_fld_), &deprecated_registers[DEPRECATED_REGISTER_BYTE (_regi_)], \ - REGISTER_RAW_SIZE (_regi_)) + DEPRECATED_REGISTER_RAW_SIZE (_regi_)) for (regi = IA64_GR0_REGNUM; regi <= IA64_GR31_REGNUM; regi++) { @@ -110,10 +110,10 @@ fill_gregset (prgregset_t *gregsetp, int regno) { memcpy (&(gregsetp->__bspstore), &deprecated_registers[DEPRECATED_REGISTER_BYTE (IA64_BSP_REGNUM)], - REGISTER_RAW_SIZE (IA64_BSP_REGNUM)); + DEPRECATED_REGISTER_RAW_SIZE (IA64_BSP_REGNUM)); memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (IA64_BSPSTORE_REGNUM)], &deprecated_registers[DEPRECATED_REGISTER_BYTE (IA64_BSP_REGNUM)], - REGISTER_RAW_SIZE (IA64_BSP_REGNUM)); + DEPRECATED_REGISTER_RAW_SIZE (IA64_BSP_REGNUM)); } #if 0 @@ -156,7 +156,7 @@ fill_fpregset (prfpregset_t *fpregsetp, int regno) { from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)]; to = (char *) &(fpregsetp->__fpr[regi - IA64_FR0_REGNUM]); - memcpy (to, from, REGISTER_RAW_SIZE (regi)); + memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regi)); } } } diff --git a/gdb/ia64-linux-nat.c b/gdb/ia64-linux-nat.c index ebaad7cacbb..a2ca8fa9bce 100644 --- a/gdb/ia64-linux-nat.c +++ b/gdb/ia64-linux-nat.c @@ -403,7 +403,7 @@ fill_gregset (gregset_t *gregsetp, int regno) #define COPY_REG(_idx_,_regi_) \ if ((regno == -1) || regno == _regi_) \ memcpy (regp + _idx_, &deprecated_registers[DEPRECATED_REGISTER_BYTE (_regi_)], \ - REGISTER_RAW_SIZE (_regi_)) + DEPRECATED_REGISTER_RAW_SIZE (_regi_)) for (regi = IA64_GR0_REGNUM; regi <= IA64_GR31_REGNUM; regi++) { @@ -469,7 +469,7 @@ fill_fpregset (fpregset_t *fpregsetp, int regno) { from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)]; to = (char *) &((*fpregsetp)[regi - IA64_FR0_REGNUM]); - memcpy (to, from, REGISTER_RAW_SIZE (regi)); + memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regi)); } } } diff --git a/gdb/ia64-tdep.c b/gdb/ia64-tdep.c index 79c645d2ced..871f10539be 100644 --- a/gdb/ia64-tdep.c +++ b/gdb/ia64-tdep.c @@ -343,7 +343,7 @@ read_sigcontext_register (struct frame_info *frame, int regnum) regaddr = SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), regnum); if (regaddr) - return read_memory_integer (regaddr, REGISTER_RAW_SIZE (regnum)); + return read_memory_integer (regaddr, DEPRECATED_REGISTER_RAW_SIZE (regnum)); else internal_error (__FILE__, __LINE__, "read_sigcontext_register: Register %d not in struct sigcontext", regnum); @@ -716,10 +716,10 @@ ia64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, { ULONGEST reg_addr = rse_address_add (bsp, (regnum - V32_REGNUM)); reg = read_memory_integer ((CORE_ADDR)reg_addr, 8); - store_unsigned_integer (buf, REGISTER_RAW_SIZE (regnum), reg); + store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum), reg); } else - store_unsigned_integer (buf, REGISTER_RAW_SIZE (regnum), 0); + store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum), 0); } else if (IA64_NAT0_REGNUM <= regnum && regnum <= IA64_NAT31_REGNUM) { @@ -727,7 +727,7 @@ ia64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, ULONGEST unat; regcache_cooked_read_unsigned (regcache, IA64_UNAT_REGNUM, &unat); unatN_val = (unat & (1LL << (regnum - IA64_NAT0_REGNUM))) != 0; - store_unsigned_integer (buf, REGISTER_RAW_SIZE (regnum), unatN_val); + store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum), unatN_val); } else if (IA64_NAT32_REGNUM <= regnum && regnum <= IA64_NAT127_REGNUM) { @@ -762,7 +762,7 @@ ia64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, natN_val = (nat_collection >> nat_bit) & 1; } - store_unsigned_integer (buf, REGISTER_RAW_SIZE (regnum), natN_val); + store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum), natN_val); } else if (regnum == VBOF_REGNUM) { @@ -777,7 +777,7 @@ ia64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, /* The bsp points at the end of the register frame so we subtract the size of frame from it to get beginning of frame. */ vbsp = rse_address_add (bsp, -(cfm & 0x7f)); - store_unsigned_integer (buf, REGISTER_RAW_SIZE (regnum), vbsp); + store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum), vbsp); } else if (VP0_REGNUM <= regnum && regnum <= VP63_REGNUM) { @@ -799,10 +799,10 @@ ia64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, + ((regnum - VP16_REGNUM) + rrb_pr) % 48; } prN_val = (pr & (1LL << (regnum - VP0_REGNUM))) != 0; - store_unsigned_integer (buf, REGISTER_RAW_SIZE (regnum), prN_val); + store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum), prN_val); } else - memset (buf, 0, REGISTER_RAW_SIZE (regnum)); + memset (buf, 0, DEPRECATED_REGISTER_RAW_SIZE (regnum)); } static void @@ -829,7 +829,7 @@ ia64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, { ULONGEST unatN_val, unat, unatN_mask; regcache_cooked_read_unsigned (regcache, IA64_UNAT_REGNUM, &unat); - unatN_val = extract_unsigned_integer (buf, REGISTER_RAW_SIZE (regnum)); + unatN_val = extract_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum)); unatN_mask = (1LL << (regnum - IA64_NAT0_REGNUM)); if (unatN_val == 0) unat &= ~unatN_mask; @@ -853,7 +853,7 @@ ia64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, if ((cfm & 0x7f) > regnum - V32_REGNUM) gr_addr = rse_address_add (bsp, (regnum - V32_REGNUM)); - natN_val = extract_unsigned_integer (buf, REGISTER_RAW_SIZE (regnum)); + natN_val = extract_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum)); if (gr_addr != 0 && (natN_val == 0 || natN_val == 1)) { @@ -882,7 +882,7 @@ ia64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, nat_collection |= natN_mask; else nat_collection &= ~natN_mask; - store_unsigned_integer (nat_buf, REGISTER_RAW_SIZE (regnum), nat_collection); + store_unsigned_integer (nat_buf, DEPRECATED_REGISTER_RAW_SIZE (regnum), nat_collection); write_memory (nat_addr, nat_buf, 8); } } @@ -907,7 +907,7 @@ ia64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, regnum = VP16_REGNUM + ((regnum - VP16_REGNUM) + rrb_pr) % 48; } - prN_val = extract_unsigned_integer (buf, REGISTER_RAW_SIZE (regnum)); + prN_val = extract_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum)); prN_mask = (1LL << (regnum - VP0_REGNUM)); if (prN_val == 0) pr &= ~prN_mask; @@ -1593,12 +1593,12 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache, if (!valuep) valuep = dummy_valp; - memset (valuep, 0, REGISTER_RAW_SIZE (regnum)); + memset (valuep, 0, DEPRECATED_REGISTER_RAW_SIZE (regnum)); if (regnum == SP_REGNUM) { /* Handle SP values for all frames but the topmost. */ - store_unsigned_integer (valuep, REGISTER_RAW_SIZE (regnum), + store_unsigned_integer (valuep, DEPRECATED_REGISTER_RAW_SIZE (regnum), cache->base); } else if (regnum == IA64_BSP_REGNUM) @@ -1623,7 +1623,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache, bsp = rse_address_add (cache->bsp, -(cache->sof)); prev_bsp = rse_address_add (bsp, (prev_cfm & 0x7f) - ((prev_cfm >> 7) & 0x7f)); - store_unsigned_integer (valuep, REGISTER_RAW_SIZE (regnum), + store_unsigned_integer (valuep, DEPRECATED_REGISTER_RAW_SIZE (regnum), prev_bsp); } else if (regnum == IA64_CFM_REGNUM) @@ -1639,7 +1639,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache, { addr = cache->saved_regs[IA64_CFM_REGNUM]; if (addr != 0) - read_memory (addr, valuep, REGISTER_RAW_SIZE (regnum)); + read_memory (addr, valuep, DEPRECATED_REGISTER_RAW_SIZE (regnum)); } } else if (regnum == IA64_VFP_REGNUM) @@ -1649,7 +1649,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache, above. If the function lacks one of these frame pointers, we can still provide a value since we know the size of the frame. */ CORE_ADDR vfp = cache->base; - store_unsigned_integer (valuep, REGISTER_RAW_SIZE (IA64_VFP_REGNUM), vfp); + store_unsigned_integer (valuep, DEPRECATED_REGISTER_RAW_SIZE (IA64_VFP_REGNUM), vfp); } else if (VP0_REGNUM <= regnum && regnum <= VP63_REGNUM) { @@ -1673,7 +1673,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache, } prN_val = extract_bit_field ((unsigned char *) pr_valuep, regnum - VP0_REGNUM, 1); - store_unsigned_integer (valuep, REGISTER_RAW_SIZE (regnum), prN_val); + store_unsigned_integer (valuep, DEPRECATED_REGISTER_RAW_SIZE (regnum), prN_val); } else if (IA64_NAT0_REGNUM <= regnum && regnum <= IA64_NAT31_REGNUM) { @@ -1687,7 +1687,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache, &unat_optim, &unat_lval, &unat_addr, &unat_realnum, unat_valuep); unatN_val = extract_bit_field ((unsigned char *) unat_valuep, regnum - IA64_NAT0_REGNUM, 1); - store_unsigned_integer (valuep, REGISTER_RAW_SIZE (regnum), + store_unsigned_integer (valuep, DEPRECATED_REGISTER_RAW_SIZE (regnum), unatN_val); } else if (IA64_NAT32_REGNUM <= regnum && regnum <= IA64_NAT127_REGNUM) @@ -1722,7 +1722,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache, natval = (nat_collection >> nat_bit) & 1; } - store_unsigned_integer (valuep, REGISTER_RAW_SIZE (regnum), natval); + store_unsigned_integer (valuep, DEPRECATED_REGISTER_RAW_SIZE (regnum), natval); } else if (regnum == IA64_IP_REGNUM) { @@ -1738,7 +1738,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache, CORE_ADDR addr = cache->saved_regs[IA64_VRAP_REGNUM]; if (addr != 0) { - read_memory (addr, buf, REGISTER_RAW_SIZE (IA64_IP_REGNUM)); + read_memory (addr, buf, DEPRECATED_REGISTER_RAW_SIZE (IA64_IP_REGNUM)); pc = extract_unsigned_integer (buf, 8); } } @@ -1765,7 +1765,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache, CORE_ADDR addr = cache->saved_regs[IA64_VRAP_REGNUM]; if (addr != 0) { - read_memory (addr, buf, REGISTER_RAW_SIZE (IA64_IP_REGNUM)); + read_memory (addr, buf, DEPRECATED_REGISTER_RAW_SIZE (IA64_IP_REGNUM)); pc = extract_unsigned_integer (buf, 8); } } @@ -1785,7 +1785,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache, { *lvalp = lval_memory; *addrp = addr; - read_memory (addr, valuep, REGISTER_RAW_SIZE (regnum)); + read_memory (addr, valuep, DEPRECATED_REGISTER_RAW_SIZE (regnum)); } else if (cache->frameless) { @@ -1809,7 +1809,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache, addr = rse_address_add (prev_bof, (regnum - IA64_GR32_REGNUM)); *lvalp = lval_memory; *addrp = addr; - read_memory (addr, valuep, REGISTER_RAW_SIZE (regnum)); + read_memory (addr, valuep, DEPRECATED_REGISTER_RAW_SIZE (regnum)); } } else @@ -1833,7 +1833,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache, { *lvalp = lval_memory; *addrp = addr; - read_memory (addr, valuep, REGISTER_RAW_SIZE (regnum)); + read_memory (addr, valuep, DEPRECATED_REGISTER_RAW_SIZE (regnum)); } /* Otherwise, punt and get the current value of the register. */ else diff --git a/gdb/infcmd.c b/gdb/infcmd.c index cb6acf0704f..60ebbea9ee2 100644 --- a/gdb/infcmd.c +++ b/gdb/infcmd.c @@ -1592,13 +1592,13 @@ default_print_registers_info (struct gdbarch *gdbarch, file, 0, 1, 0, Val_pretty_default); fprintf_filtered (file, "\t(raw 0x"); - for (j = 0; j < REGISTER_RAW_SIZE (i); j++) + for (j = 0; j < DEPRECATED_REGISTER_RAW_SIZE (i); j++) { int idx; if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) idx = j; else - idx = REGISTER_RAW_SIZE (i) - 1 - j; + idx = DEPRECATED_REGISTER_RAW_SIZE (i) - 1 - j; fprintf_filtered (file, "%02x", (unsigned char) raw_buffer[idx]); } fprintf_filtered (file, ")"); diff --git a/gdb/infptrace.c b/gdb/infptrace.c index 1286b752fc9..ef86f90cf2e 100644 --- a/gdb/infptrace.c +++ b/gdb/infptrace.c @@ -366,7 +366,7 @@ fetch_register (int regno) if (CANNOT_FETCH_REGISTER (regno)) { - memset (buf, '\0', REGISTER_RAW_SIZE (regno)); /* Supply zeroes */ + memset (buf, '\0', DEPRECATED_REGISTER_RAW_SIZE (regno)); /* Supply zeroes */ supply_register (regno, buf); return; } @@ -378,7 +378,7 @@ fetch_register (int regno) offset = U_REGS_OFFSET; regaddr = register_addr (regno, offset); - for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE)) + for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE)) { errno = 0; *(PTRACE_XFER_TYPE *) & buf[i] = ptrace (PT_READ_U, tid, @@ -445,7 +445,7 @@ store_register (int regno) regcache_collect (regno, buf); /* Store the local buffer into the inferior a chunk at the time. */ - for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE)) + for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE)) { errno = 0; ptrace (PT_WRITE_U, tid, (PTRACE_ARG3_TYPE) regaddr, diff --git a/gdb/infrun.c b/gdb/infrun.c index 792e0803019..e22a90a9267 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -3622,7 +3622,7 @@ void write_inferior_status_register (struct inferior_status *inf_status, int regno, LONGEST val) { - int size = REGISTER_RAW_SIZE (regno); + int size = DEPRECATED_REGISTER_RAW_SIZE (regno); void *buf = alloca (size); store_signed_integer (buf, size, val); regcache_raw_write (inf_status->registers, regno, buf); diff --git a/gdb/irix5-nat.c b/gdb/irix5-nat.c index f7c20343f0c..224d376f97f 100644 --- a/gdb/irix5-nat.c +++ b/gdb/irix5-nat.c @@ -84,27 +84,27 @@ fill_gregset (gregset_t *gregsetp, int regno) if ((regno == -1) || (regno == regi)) *(regp + regi) = extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)], - REGISTER_RAW_SIZE (regi)); + DEPRECATED_REGISTER_RAW_SIZE (regi)); if ((regno == -1) || (regno == PC_REGNUM)) *(regp + CTX_EPC) = extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)], - REGISTER_RAW_SIZE (PC_REGNUM)); + DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM)); if ((regno == -1) || (regno == CAUSE_REGNUM)) *(regp + CTX_CAUSE) = extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (CAUSE_REGNUM)], - REGISTER_RAW_SIZE (CAUSE_REGNUM)); + DEPRECATED_REGISTER_RAW_SIZE (CAUSE_REGNUM)); if ((regno == -1) || (regno == HI_REGNUM)) *(regp + CTX_MDHI) = extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (HI_REGNUM)], - REGISTER_RAW_SIZE (HI_REGNUM)); + DEPRECATED_REGISTER_RAW_SIZE (HI_REGNUM)); if ((regno == -1) || (regno == LO_REGNUM)) *(regp + CTX_MDLO) = extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (LO_REGNUM)], - REGISTER_RAW_SIZE (LO_REGNUM)); + DEPRECATED_REGISTER_RAW_SIZE (LO_REGNUM)); } /* @@ -147,7 +147,7 @@ fill_fpregset (fpregset_t *fpregsetp, int regno) { from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)]; to = (char *) &(fpregsetp->fp_r.fp_regs[regi - FP0_REGNUM]); - memcpy (to, from, REGISTER_RAW_SIZE (regi)); + memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regi)); } } @@ -219,7 +219,7 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, *dstp++ = *srcp++; *dstp++ = *srcp++; *dstp++ = *srcp++; - if (REGISTER_RAW_SIZE (regno) == 4) + if (DEPRECATED_REGISTER_RAW_SIZE (regno) == 4) { /* copying 4 bytes from eight bytes? I don't see how this can be right... */ diff --git a/gdb/lynx-nat.c b/gdb/lynx-nat.c index bbd88b60906..b0e2402d79c 100644 --- a/gdb/lynx-nat.c +++ b/gdb/lynx-nat.c @@ -293,12 +293,12 @@ fetch_inferior_registers (int regno) if (errno) perror_with_name ("ptrace(PTRACE_GETREGS)"); - memset (buf, 0, REGISTER_RAW_SIZE (G0_REGNUM)); + memset (buf, 0, DEPRECATED_REGISTER_RAW_SIZE (G0_REGNUM)); supply_register (G0_REGNUM, buf); supply_register (TBR_REGNUM, (char *) &ec.tbr); memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (G1_REGNUM)], &ec.g1, - 4 * REGISTER_RAW_SIZE (G1_REGNUM)); + 4 * DEPRECATED_REGISTER_RAW_SIZE (G1_REGNUM)); for (i = G1_REGNUM; i <= G1_REGNUM + 3; i++) deprecated_register_valid[i] = 1; @@ -309,7 +309,7 @@ fetch_inferior_registers (int regno) supply_register (WIM_REGNUM, (char *) &ec.wim); memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (O0_REGNUM)], ec.o, - 8 * REGISTER_RAW_SIZE (O0_REGNUM)); + 8 * DEPRECATED_REGISTER_RAW_SIZE (O0_REGNUM)); for (i = O0_REGNUM; i <= O0_REGNUM + 7; i++) deprecated_register_valid[i] = 1; } @@ -323,13 +323,13 @@ fetch_inferior_registers (int regno) target_read_memory (sp + FRAME_SAVED_I0, &deprecated_registers[DEPRECATED_REGISTER_BYTE (I0_REGNUM)], - 8 * REGISTER_RAW_SIZE (I0_REGNUM)); + 8 * DEPRECATED_REGISTER_RAW_SIZE (I0_REGNUM)); for (i = I0_REGNUM; i <= I7_REGNUM; i++) deprecated_register_valid[i] = 1; target_read_memory (sp + FRAME_SAVED_L0, &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)], - 8 * REGISTER_RAW_SIZE (L0_REGNUM)); + 8 * DEPRECATED_REGISTER_RAW_SIZE (L0_REGNUM)); for (i = L0_REGNUM; i <= L0_REGNUM + 7; i++) deprecated_register_valid[i] = 1; } @@ -347,7 +347,7 @@ fetch_inferior_registers (int regno) perror_with_name ("ptrace(PTRACE_GETFPREGS)"); memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)], fc.f.fregs, - 32 * REGISTER_RAW_SIZE (FP0_REGNUM)); + 32 * DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM)); for (i = FP0_REGNUM; i <= FP0_REGNUM + 31; i++) deprecated_register_valid[i] = 1; @@ -385,7 +385,7 @@ store_inferior_registers (int regno) ec.tbr = read_register (TBR_REGNUM); memcpy (&ec.g1, &deprecated_registers[DEPRECATED_REGISTER_BYTE (G1_REGNUM)], - 4 * REGISTER_RAW_SIZE (G1_REGNUM)); + 4 * DEPRECATED_REGISTER_RAW_SIZE (G1_REGNUM)); ec.psr = read_register (PS_REGNUM); ec.y = read_register (Y_REGNUM); @@ -394,7 +394,7 @@ store_inferior_registers (int regno) ec.wim = read_register (WIM_REGNUM); memcpy (ec.o, &deprecated_registers[DEPRECATED_REGISTER_BYTE (O0_REGNUM)], - 8 * REGISTER_RAW_SIZE (O0_REGNUM)); + 8 * DEPRECATED_REGISTER_RAW_SIZE (O0_REGNUM)); errno = 0; retval = ptrace (PTRACE_SETREGS, PIDGET (inferior_ptid), @@ -416,11 +416,11 @@ store_inferior_registers (int regno) internal_error (__FILE__, __LINE__, "failed internal consistency check"); target_write_memory (sp + FRAME_SAVED_I0, &deprecated_registers[DEPRECATED_REGISTER_BYTE (I0_REGNUM)], - 8 * REGISTER_RAW_SIZE (I0_REGNUM)); + 8 * DEPRECATED_REGISTER_RAW_SIZE (I0_REGNUM)); target_write_memory (sp + FRAME_SAVED_L0, &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)], - 8 * REGISTER_RAW_SIZE (L0_REGNUM)); + 8 * DEPRECATED_REGISTER_RAW_SIZE (L0_REGNUM)); } else if (regno >= L0_REGNUM && regno <= I7_REGNUM) { @@ -434,7 +434,7 @@ store_inferior_registers (int regno) + FRAME_SAVED_I0; target_write_memory (sp + regoffset, &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)], - REGISTER_RAW_SIZE (regno)); + DEPRECATED_REGISTER_RAW_SIZE (regno)); } } @@ -451,7 +451,7 @@ store_inferior_registers (int regno) perror_with_name ("ptrace(PTRACE_GETFPREGS)"); memcpy (fc.f.fregs, &deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)], - 32 * REGISTER_RAW_SIZE (FP0_REGNUM)); + 32 * DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM)); fc.fsr = read_register (FPS_REGNUM); @@ -521,7 +521,7 @@ fetch_inferior_registers (int regno) ptrace_fun = regno == SP_REGNUM ? PTRACE_PEEKUSP : PTRACE_PEEKTHREAD; #endif - for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int)) + for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (int)) { unsigned int reg; @@ -570,7 +570,7 @@ store_inferior_registers (int regno) ptrace_fun = regno == SP_REGNUM ? PTRACE_POKEUSP : PTRACE_POKEUSER; #endif - for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int)) + for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (int)) { unsigned int reg; diff --git a/gdb/mi/ChangeLog b/gdb/mi/ChangeLog index a74558507f1..9a88e2f8635 100644 --- a/gdb/mi/ChangeLog +++ b/gdb/mi/ChangeLog @@ -1,3 +1,8 @@ +2003-10-02 Andrew Cagney <cagney@redhat.com> + + * mi-main.c: Rename REGISTER_RAW_SIZE to + DEPRECATED_REGISTER_RAW_SIZE. + 2003-09-30 Andrew Cagney <cagney@redhat.com> * mi-main.c: Rename REGISTER_VIRTUAL_SIZE to @@ -5,7 +10,7 @@ 2003-09-17 Andrew Cagney <cagney@redhat.com> - * mi/mi-main.c: Rename REGISTER_BYTE to DEPRECATED_REGISTER_BYTE. + * mi-main.c: Rename REGISTER_BYTE to DEPRECATED_REGISTER_BYTE. 2003-09-10 Elena Zannoni <ezannoni@redhat.com> diff --git a/gdb/mi/mi-main.c b/gdb/mi/mi-main.c index 51130a39a62..19eba99bded 100644 --- a/gdb/mi/mi-main.c +++ b/gdb/mi/mi-main.c @@ -406,13 +406,13 @@ register_changed_p (int regnum) return -1; if (memcmp (&old_regs[DEPRECATED_REGISTER_BYTE (regnum)], raw_buffer, - REGISTER_RAW_SIZE (regnum)) == 0) + DEPRECATED_REGISTER_RAW_SIZE (regnum)) == 0) return 0; /* Found a changed register. Return 1. */ memcpy (&old_regs[DEPRECATED_REGISTER_BYTE (regnum)], raw_buffer, - REGISTER_RAW_SIZE (regnum)); + DEPRECATED_REGISTER_RAW_SIZE (regnum)); return 1; } @@ -553,10 +553,10 @@ get_register (int regnum, int format) strcpy (buf, "0x"); ptr = buf + 2; - for (j = 0; j < REGISTER_RAW_SIZE (regnum); j++) + for (j = 0; j < DEPRECATED_REGISTER_RAW_SIZE (regnum); j++) { int idx = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? j - : REGISTER_RAW_SIZE (regnum) - 1 - j; + : DEPRECATED_REGISTER_RAW_SIZE (regnum) - 1 - j; sprintf (ptr, "%02x", (unsigned char) raw_buffer[idx]); ptr += 2; } @@ -642,7 +642,7 @@ mi_cmd_data_write_register_values (char *command, char **argv, int argc) old_chain = make_cleanup (xfree, buffer); store_signed_integer (buffer, DEPRECATED_REGISTER_SIZE, value); /* Write it down */ - deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (regnum), buffer, REGISTER_RAW_SIZE (regnum)); + deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (regnum), buffer, DEPRECATED_REGISTER_RAW_SIZE (regnum)); /* Free the buffer. */ do_cleanups (old_chain); } diff --git a/gdb/mips-linux-tdep.c b/gdb/mips-linux-tdep.c index 8f31cf2ad5d..20ada7b9477 100644 --- a/gdb/mips-linux-tdep.c +++ b/gdb/mips-linux-tdep.c @@ -92,7 +92,7 @@ static void supply_32bit_reg (int regnum, const void *addr) { char buf[MAX_REGISTER_SIZE]; - store_signed_integer (buf, REGISTER_RAW_SIZE (regnum), + store_signed_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum), extract_signed_integer (addr, 4)); supply_register (regnum, buf); } @@ -218,13 +218,13 @@ fill_fpregset (elf_fpregset_t *fpregsetp, int regno) { from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)]; to = (char *) (*fpregsetp + regno - FP0_REGNUM); - memcpy (to, from, REGISTER_RAW_SIZE (regno - FP0_REGNUM)); + memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regno - FP0_REGNUM)); } else if (regno == FCRCS_REGNUM) { from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)]; to = (char *) (*fpregsetp + 32); - memcpy (to, from, REGISTER_RAW_SIZE (regno)); + memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regno)); } else if (regno == -1) { @@ -493,13 +493,13 @@ mips64_fill_fpregset (mips64_elf_fpregset_t *fpregsetp, int regno) { from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)]; to = (char *) (*fpregsetp + regno - FP0_REGNUM); - memcpy (to, from, REGISTER_RAW_SIZE (regno - FP0_REGNUM)); + memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regno - FP0_REGNUM)); } else if (regno == FCRCS_REGNUM) { from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)]; to = (char *) (*fpregsetp + 32); - memcpy (to, from, REGISTER_RAW_SIZE (regno)); + memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regno)); } else if (regno == -1) { diff --git a/gdb/mips-nat.c b/gdb/mips-nat.c index 0ab3fb1dd6b..4c359860ef2 100644 --- a/gdb/mips-nat.c +++ b/gdb/mips-nat.c @@ -83,7 +83,7 @@ fetch_inferior_registers (int regno) for (regno = 1; regno < NUM_REGS; regno++) { regaddr = register_ptrace_addr (regno); - for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int)) + for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (int)) { *(int *) &buf[i] = ptrace (PT_READ_U, PIDGET (inferior_ptid), (PTRACE_ARG3_TYPE) regaddr, 0); diff --git a/gdb/mips-tdep.c b/gdb/mips-tdep.c index 5a4ea2451a3..4440e113c0a 100644 --- a/gdb/mips-tdep.c +++ b/gdb/mips-tdep.c @@ -181,9 +181,9 @@ unmake_mips16_addr (CORE_ADDR addr) static LONGEST read_signed_register (int regnum) { - void *buf = alloca (REGISTER_RAW_SIZE (regnum)); + void *buf = alloca (DEPRECATED_REGISTER_RAW_SIZE (regnum)); deprecated_read_register_gen (regnum, buf); - return (extract_signed_integer (buf, REGISTER_RAW_SIZE (regnum))); + return (extract_signed_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum))); } static LONGEST @@ -279,7 +279,7 @@ mips_xfer_register (struct regcache *regcache, int reg_num, int length, switch (endian) { case BFD_ENDIAN_BIG: - reg_offset = REGISTER_RAW_SIZE (reg_num) - length; + reg_offset = DEPRECATED_REGISTER_RAW_SIZE (reg_num) - length; break; case BFD_ENDIAN_LITTLE: reg_offset = 0; @@ -325,7 +325,7 @@ mips2_fp_compat (void) { /* MIPS1 and MIPS2 have only 32 bit FPRs, and the FR bit is not meaningful. */ - if (REGISTER_RAW_SIZE (FP0_REGNUM) == 4) + if (DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM) == 4) return 0; #if 0 @@ -654,7 +654,7 @@ mips_register_raw_size (int regnum) NOTE: cagney/2003-06-15: This is so bogus. The register's raw size is changing according to the ABI (FP_REGISTER_DOUBLE). Also, GDB's protocol is defined by a - combination of REGISTER_RAW_SIZE and DEPRECATED_REGISTER_BYTE. */ + combination of DEPRECATED_REGISTER_RAW_SIZE and DEPRECATED_REGISTER_BYTE. */ if (mips64_transfers_32bit_regs_p) return DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum); else if (regnum >= FP0_REGNUM && regnum < FP0_REGNUM + 32 @@ -717,7 +717,7 @@ mips_register_convertible (int reg_nr) if (mips64_transfers_32bit_regs_p) return 0; else - return (REGISTER_RAW_SIZE (reg_nr) > DEPRECATED_REGISTER_VIRTUAL_SIZE (reg_nr)); + return (DEPRECATED_REGISTER_RAW_SIZE (reg_nr) > DEPRECATED_REGISTER_VIRTUAL_SIZE (reg_nr)); } static void @@ -726,7 +726,7 @@ mips_register_convert_to_virtual (int n, struct type *virtual_type, { if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) memcpy (virt_buf, - raw_buf + (REGISTER_RAW_SIZE (n) - TYPE_LENGTH (virtual_type)), + raw_buf + (DEPRECATED_REGISTER_RAW_SIZE (n) - TYPE_LENGTH (virtual_type)), TYPE_LENGTH (virtual_type)); else memcpy (virt_buf, @@ -738,9 +738,9 @@ static void mips_register_convert_to_raw (struct type *virtual_type, int n, const char *virt_buf, char *raw_buf) { - memset (raw_buf, 0, REGISTER_RAW_SIZE (n)); + memset (raw_buf, 0, DEPRECATED_REGISTER_RAW_SIZE (n)); if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) - memcpy (raw_buf + (REGISTER_RAW_SIZE (n) - TYPE_LENGTH (virtual_type)), + memcpy (raw_buf + (DEPRECATED_REGISTER_RAW_SIZE (n) - TYPE_LENGTH (virtual_type)), virt_buf, TYPE_LENGTH (virtual_type)); else @@ -753,7 +753,7 @@ static int mips_convert_register_p (int regnum, struct type *type) { return (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG - && REGISTER_RAW_SIZE (regnum) == 4 + && DEPRECATED_REGISTER_RAW_SIZE (regnum) == 4 && (regnum) >= FP0_REGNUM && (regnum) < FP0_REGNUM + 32 && TYPE_CODE(type) == TYPE_CODE_FLT && TYPE_LENGTH(type) == 8); @@ -4065,7 +4065,7 @@ static void mips_read_fp_register_single (struct frame_info *frame, int regno, char *rare_buffer) { - int raw_size = REGISTER_RAW_SIZE (regno); + int raw_size = DEPRECATED_REGISTER_RAW_SIZE (regno); char *raw_buffer = alloca (raw_size); if (!frame_register_read (frame, regno, raw_buffer)) @@ -4097,7 +4097,7 @@ static void mips_read_fp_register_double (struct frame_info *frame, int regno, char *rare_buffer) { - int raw_size = REGISTER_RAW_SIZE (regno); + int raw_size = DEPRECATED_REGISTER_RAW_SIZE (regno); if (raw_size == 8 && !mips2_fp_compat ()) { @@ -4136,13 +4136,13 @@ mips_print_fp_register (struct ui_file *file, struct frame_info *frame, double doub, flt1, flt2; /* doubles extracted from raw hex data */ int inv1, inv2, namelen; - raw_buffer = (char *) alloca (2 * REGISTER_RAW_SIZE (FP0_REGNUM)); + raw_buffer = (char *) alloca (2 * DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM)); fprintf_filtered (file, "%s:", REGISTER_NAME (regnum)); fprintf_filtered (file, "%*s", 4 - (int) strlen (REGISTER_NAME (regnum)), ""); - if (REGISTER_RAW_SIZE (regnum) == 4 || mips2_fp_compat ()) + if (DEPRECATED_REGISTER_RAW_SIZE (regnum) == 4 || mips2_fp_compat ()) { /* 4-byte registers: Print hex and floating. Also print even numbered registers as doubles. */ @@ -4229,7 +4229,7 @@ mips_print_register (struct ui_file *file, struct frame_info *frame, fprintf_filtered (file, ": "); if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) - offset = REGISTER_RAW_SIZE (regnum) - DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum); + offset = DEPRECATED_REGISTER_RAW_SIZE (regnum) - DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum); else offset = 0; @@ -4301,8 +4301,8 @@ print_gp_register_row (struct ui_file *file, struct frame_info *frame, printf_filtered (" "); /* Now print the register value in hex, endian order. */ if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) - for (byte = REGISTER_RAW_SIZE (regnum) - DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum); - byte < REGISTER_RAW_SIZE (regnum); + for (byte = DEPRECATED_REGISTER_RAW_SIZE (regnum) - DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum); + byte < DEPRECATED_REGISTER_RAW_SIZE (regnum); byte++) fprintf_filtered (file, "%02x", (unsigned char) raw_buffer[byte]); else @@ -4641,7 +4641,7 @@ return_value_location (struct type *valtype, lo->buf_offset = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? 4 : 0; hi->buf_offset = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? 0 : 4; lo->reg_offset = ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG - && REGISTER_RAW_SIZE (FP0_REGNUM) == 8) + && DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM) == 8) ? 4 : 0); hi->reg_offset = lo->reg_offset; lo->reg = FP0_REGNUM + 0; @@ -4654,7 +4654,7 @@ return_value_location (struct type *valtype, /* The floating point value fits in a single floating-point register. */ lo->reg_offset = ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG - && REGISTER_RAW_SIZE (FP0_REGNUM) == 8 + && DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM) == 8 && len == 4) ? 4 : 0); lo->reg = FP0_REGNUM; @@ -4710,7 +4710,7 @@ return_value_location (struct type *valtype, } } if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG - && REGISTER_RAW_SIZE (regnum) == 8 + && DEPRECATED_REGISTER_RAW_SIZE (regnum) == 8 && MIPS_SAVED_REGSIZE == 4) { /* Account for the fact that only the least-signficant part @@ -4778,14 +4778,14 @@ mips_eabi_store_return_value (struct type *valtype, char *valbuf) memset (raw_buffer, 0, sizeof (raw_buffer)); memcpy (raw_buffer + lo.reg_offset, valbuf + lo.buf_offset, lo.len); deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (lo.reg), raw_buffer, - REGISTER_RAW_SIZE (lo.reg)); + DEPRECATED_REGISTER_RAW_SIZE (lo.reg)); if (hi.len > 0) { memset (raw_buffer, 0, sizeof (raw_buffer)); memcpy (raw_buffer + hi.reg_offset, valbuf + hi.buf_offset, hi.len); deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (hi.reg), raw_buffer, - REGISTER_RAW_SIZE (hi.reg)); + DEPRECATED_REGISTER_RAW_SIZE (hi.reg)); } } @@ -4800,14 +4800,14 @@ mips_o64_store_return_value (struct type *valtype, char *valbuf) memset (raw_buffer, 0, sizeof (raw_buffer)); memcpy (raw_buffer + lo.reg_offset, valbuf + lo.buf_offset, lo.len); deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (lo.reg), raw_buffer, - REGISTER_RAW_SIZE (lo.reg)); + DEPRECATED_REGISTER_RAW_SIZE (lo.reg)); if (hi.len > 0) { memset (raw_buffer, 0, sizeof (raw_buffer)); memcpy (raw_buffer + hi.reg_offset, valbuf + hi.buf_offset, hi.len); deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (hi.reg), raw_buffer, - REGISTER_RAW_SIZE (hi.reg)); + DEPRECATED_REGISTER_RAW_SIZE (hi.reg)); } } @@ -4902,9 +4902,9 @@ mips_o32_xfer_return_value (struct type *type, int regnum; for (offset = 0, regnum = V0_REGNUM; offset < TYPE_LENGTH (type); - offset += REGISTER_RAW_SIZE (regnum), regnum++) + offset += DEPRECATED_REGISTER_RAW_SIZE (regnum), regnum++) { - int xfer = REGISTER_RAW_SIZE (regnum); + int xfer = DEPRECATED_REGISTER_RAW_SIZE (regnum); if (offset + xfer > TYPE_LENGTH (type)) xfer = TYPE_LENGTH (type) - offset; if (mips_debug) @@ -5013,9 +5013,9 @@ mips_n32n64_xfer_return_value (struct type *type, int regnum; for (offset = 0, regnum = V0_REGNUM; offset < TYPE_LENGTH (type); - offset += REGISTER_RAW_SIZE (regnum), regnum++) + offset += DEPRECATED_REGISTER_RAW_SIZE (regnum), regnum++) { - int xfer = REGISTER_RAW_SIZE (regnum); + int xfer = DEPRECATED_REGISTER_RAW_SIZE (regnum); if (offset + xfer > TYPE_LENGTH (type)) xfer = TYPE_LENGTH (type) - offset; if (mips_debug) @@ -5033,9 +5033,9 @@ mips_n32n64_xfer_return_value (struct type *type, int regnum; for (offset = 0, regnum = V0_REGNUM; offset < TYPE_LENGTH (type); - offset += REGISTER_RAW_SIZE (regnum), regnum++) + offset += DEPRECATED_REGISTER_RAW_SIZE (regnum), regnum++) { - int xfer = REGISTER_RAW_SIZE (regnum); + int xfer = DEPRECATED_REGISTER_RAW_SIZE (regnum); int pos = 0; if (offset + xfer > TYPE_LENGTH (type)) xfer = TYPE_LENGTH (type) - offset; diff --git a/gdb/mipsv4-nat.c b/gdb/mipsv4-nat.c index 1c753890a85..686d2564ba6 100644 --- a/gdb/mipsv4-nat.c +++ b/gdb/mipsv4-nat.c @@ -127,7 +127,7 @@ fill_fpregset (fpregset_t *fpregsetp, int regno) { from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)]; to = (char *) &(fpregsetp->fp_r.fp_regs[regi - FP0_REGNUM]); - memcpy (to, from, REGISTER_RAW_SIZE (regi)); + memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regi)); } } diff --git a/gdb/mn10300-tdep.c b/gdb/mn10300-tdep.c index 0cbff1d3448..42c54fc8475 100644 --- a/gdb/mn10300-tdep.c +++ b/gdb/mn10300-tdep.c @@ -134,7 +134,7 @@ static CORE_ADDR mn10300_extract_struct_value_address (char *regbuf) { return extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (4), - REGISTER_RAW_SIZE (4)); + DEPRECATED_REGISTER_RAW_SIZE (4)); } static void @@ -749,7 +749,7 @@ mn10300_pop_frame_regular (struct frame_info *frame) ULONGEST value; value = read_memory_unsigned_integer (deprecated_get_frame_saved_regs (frame)[regnum], - REGISTER_RAW_SIZE (regnum)); + DEPRECATED_REGISTER_RAW_SIZE (regnum)); write_register (regnum, value); } @@ -1039,8 +1039,8 @@ mn10300_print_register (const char *name, int regnum, int reg_width) int byte; if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) { - for (byte = REGISTER_RAW_SIZE (regnum) - DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum); - byte < REGISTER_RAW_SIZE (regnum); + for (byte = DEPRECATED_REGISTER_RAW_SIZE (regnum) - DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum); + byte < DEPRECATED_REGISTER_RAW_SIZE (regnum); byte++) printf_filtered ("%02x", (unsigned char) raw_buffer[byte]); } diff --git a/gdb/monitor.c b/gdb/monitor.c index 77bde82baef..e2e86870d14 100644 --- a/gdb/monitor.c +++ b/gdb/monitor.c @@ -929,7 +929,7 @@ monitor_supply_register (int regno, char *valstr) /* supply register stores in target byte order, so swap here */ - store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), val); + store_unsigned_integer (regbuf, DEPRECATED_REGISTER_RAW_SIZE (regno), val); supply_register (regno, regbuf); @@ -1235,7 +1235,7 @@ monitor_fetch_register (int regno) spaces, but stop reading if something else is seen. Some monitors like to drop leading zeros. */ - for (i = 0; i < REGISTER_RAW_SIZE (regno) * 2; i++) + for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno) * 2; i++) { int c; c = readchar (timeout); @@ -1352,7 +1352,7 @@ monitor_store_register (int regno) val = read_register (regno); monitor_debug ("MON storeg %d %s\n", regno, - phex (val, REGISTER_RAW_SIZE (regno))); + phex (val, DEPRECATED_REGISTER_RAW_SIZE (regno))); /* send the register deposit command */ diff --git a/gdb/ns32k-tdep.c b/gdb/ns32k-tdep.c index 00c204fb5c0..d426113f222 100644 --- a/gdb/ns32k-tdep.c +++ b/gdb/ns32k-tdep.c @@ -498,7 +498,7 @@ ns32k_store_return_value (struct type *valtype, char *valbuf) static CORE_ADDR ns32k_extract_struct_value_address (char *regbuf) { - return (extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (0), REGISTER_RAW_SIZE (0))); + return (extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (0), DEPRECATED_REGISTER_RAW_SIZE (0))); } void diff --git a/gdb/ppc-linux-nat.c b/gdb/ppc-linux-nat.c index be278f91d66..8227aa858fd 100644 --- a/gdb/ppc-linux-nat.c +++ b/gdb/ppc-linux-nat.c @@ -178,7 +178,7 @@ fetch_altivec_register (int tid, int regno) int offset = 0; gdb_vrregset_t regs; struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); - int vrregsize = REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum); + int vrregsize = DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum); ret = ptrace (PTRACE_GETVRREGS, tid, 0, ®s); if (ret < 0) @@ -196,7 +196,7 @@ fetch_altivec_register (int tid, int regno) vector. VRSAVE is at the end of the array in a 4 bytes slot, so there is no need to define an offset for it. */ if (regno == (tdep->ppc_vrsave_regnum - 1)) - offset = vrregsize - REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum); + offset = vrregsize - DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum); supply_register (regno, regs + (regno - tdep->ppc_vr0_regnum) * vrregsize + offset); @@ -230,12 +230,12 @@ fetch_register (int tid, int regno) if (regaddr == -1) { - memset (buf, '\0', REGISTER_RAW_SIZE (regno)); /* Supply zeroes */ + memset (buf, '\0', DEPRECATED_REGISTER_RAW_SIZE (regno)); /* Supply zeroes */ supply_register (regno, buf); return; } - for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE)) + for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE)) { errno = 0; *(PTRACE_XFER_TYPE *) & buf[i] = ptrace (PT_READ_U, tid, @@ -257,8 +257,8 @@ supply_vrregset (gdb_vrregset_t *vrregsetp) int i; struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); int num_of_vrregs = tdep->ppc_vrsave_regnum - tdep->ppc_vr0_regnum + 1; - int vrregsize = REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum); - int offset = vrregsize - REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum); + int vrregsize = DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum); + int offset = vrregsize - DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum); for (i = 0; i < num_of_vrregs; i++) { @@ -335,7 +335,7 @@ store_altivec_register (int tid, int regno) int offset = 0; gdb_vrregset_t regs; struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); - int vrregsize = REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum); + int vrregsize = DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum); ret = ptrace (PTRACE_GETVRREGS, tid, 0, ®s); if (ret < 0) @@ -351,7 +351,7 @@ store_altivec_register (int tid, int regno) /* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes long on the hardware. */ if (regno == (tdep->ppc_vrsave_regnum - 1)) - offset = vrregsize - REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum); + offset = vrregsize - DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum); regcache_collect (regno, regs + (regno - tdep->ppc_vr0_regnum) * vrregsize + offset); @@ -381,7 +381,7 @@ store_register (int tid, int regno) return; regcache_collect (regno, buf); - for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE)) + for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE)) { errno = 0; ptrace (PT_WRITE_U, tid, (PTRACE_ARG3_TYPE) regaddr, @@ -410,8 +410,8 @@ fill_vrregset (gdb_vrregset_t *vrregsetp) int i; struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); int num_of_vrregs = tdep->ppc_vrsave_regnum - tdep->ppc_vr0_regnum + 1; - int vrregsize = REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum); - int offset = vrregsize - REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum); + int vrregsize = DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum); + int offset = vrregsize - DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum); for (i = 0; i < num_of_vrregs; i++) { diff --git a/gdb/regcache.c b/gdb/regcache.c index a36cd1e5fe5..ccb4e8064bb 100644 --- a/gdb/regcache.c +++ b/gdb/regcache.c @@ -112,8 +112,8 @@ init_legacy_regcache_descr (struct gdbarch *gdbarch, to overlap. Ulgh! New targets use gdbarch's register read/write and entirely avoid this uglyness. */ descr->register_offset[i] = DEPRECATED_REGISTER_BYTE (i); - descr->sizeof_register[i] = REGISTER_RAW_SIZE (i); - gdb_assert (MAX_REGISTER_SIZE >= REGISTER_RAW_SIZE (i)); + descr->sizeof_register[i] = DEPRECATED_REGISTER_RAW_SIZE (i); + gdb_assert (MAX_REGISTER_SIZE >= DEPRECATED_REGISTER_RAW_SIZE (i)); gdb_assert (MAX_REGISTER_SIZE >= DEPRECATED_REGISTER_VIRTUAL_SIZE (i)); } @@ -187,7 +187,7 @@ init_regcache_descr (struct gdbarch *gdbarch) /* If an old style architecture, fill in the remainder of the register cache descriptor using the register macros. */ /* NOTE: cagney/2003-06-29: If either of DEPRECATED_REGISTER_BYTE or - REGISTER_RAW_SIZE are still present, things are most likely + DEPRECATED_REGISTER_RAW_SIZE are still present, things are most likely totally screwed. Ex: an architecture with raw register sizes smaller than what DEPRECATED_REGISTER_BYTE indicates; non monotonic DEPRECATED_REGISTER_BYTE values. For GDB 6 check for @@ -196,7 +196,8 @@ init_regcache_descr (struct gdbarch *gdbarch) if ((!gdbarch_pseudo_register_read_p (gdbarch) && !gdbarch_pseudo_register_write_p (gdbarch) && !gdbarch_register_type_p (gdbarch)) - || DEPRECATED_REGISTER_BYTE_P () || REGISTER_RAW_SIZE_P ()) + || DEPRECATED_REGISTER_BYTE_P () + || DEPRECATED_REGISTER_RAW_SIZE_P ()) { descr->legacy_p = 1; init_legacy_regcache_descr (gdbarch, descr); @@ -242,7 +243,7 @@ init_regcache_descr (struct gdbarch *gdbarch) if (DEPRECATED_REGISTER_BYTE_P ()) gdb_assert (descr->register_offset[i] == DEPRECATED_REGISTER_BYTE (i)); #if 0 - gdb_assert (descr->sizeof_register[i] == REGISTER_RAW_SIZE (i)); + gdb_assert (descr->sizeof_register[i] == DEPRECATED_REGISTER_RAW_SIZE (i)); gdb_assert (descr->sizeof_register[i] == DEPRECATED_REGISTER_VIRTUAL_SIZE (i)); #endif } @@ -278,9 +279,9 @@ register_size (struct gdbarch *gdbarch, int regnum) int size; gdb_assert (regnum >= 0 && regnum < (NUM_REGS + NUM_PSEUDO_REGS)); size = descr->sizeof_register[regnum]; - /* NB: The deprecated REGISTER_RAW_SIZE, if not provided, defaults + /* NB: The deprecated DEPRECATED_REGISTER_RAW_SIZE, if not provided, defaults to the size of the register's type. */ - gdb_assert (size == REGISTER_RAW_SIZE (regnum)); /* OK */ + gdb_assert (size == DEPRECATED_REGISTER_RAW_SIZE (regnum)); /* OK */ /* NB: Don't check the register's virtual size. It, in say the case of the MIPS, may not match the raw size! */ return size; @@ -661,7 +662,7 @@ deprecated_read_register_bytes (int in_start, char *in_buf, int in_len) int byte; reg_start = DEPRECATED_REGISTER_BYTE (regnum); - reg_len = REGISTER_RAW_SIZE (regnum); + reg_len = DEPRECATED_REGISTER_RAW_SIZE (regnum); reg_end = reg_start + reg_len; if (reg_end <= in_start || in_end <= reg_start) @@ -726,7 +727,7 @@ legacy_read_register_gen (int regnum, char *myaddr) target_fetch_registers (regnum); memcpy (myaddr, register_buffer (current_regcache, regnum), - REGISTER_RAW_SIZE (regnum)); + DEPRECATED_REGISTER_RAW_SIZE (regnum)); } void @@ -913,7 +914,7 @@ legacy_write_register_gen (int regnum, const void *myaddr) registers_ptid = inferior_ptid; } - size = REGISTER_RAW_SIZE (regnum); + size = DEPRECATED_REGISTER_RAW_SIZE (regnum); if (real_register (regnum)) { @@ -1023,7 +1024,7 @@ deprecated_write_register_bytes (int myregstart, char *myaddr, int inlen) int regstart, regend; regstart = DEPRECATED_REGISTER_BYTE (regnum); - regend = regstart + REGISTER_RAW_SIZE (regnum); + regend = regstart + DEPRECATED_REGISTER_RAW_SIZE (regnum); /* Is this register completely outside the range the user is writing? */ if (myregend <= regstart || regend <= myregstart) @@ -1152,9 +1153,9 @@ register_offset_hack (struct gdbarch *gdbarch, int regnum) ULONGEST read_register (int regnum) { - char *buf = alloca (REGISTER_RAW_SIZE (regnum)); + char *buf = alloca (DEPRECATED_REGISTER_RAW_SIZE (regnum)); deprecated_read_register_gen (regnum, buf); - return (extract_unsigned_integer (buf, REGISTER_RAW_SIZE (regnum))); + return (extract_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum))); } ULONGEST @@ -1185,7 +1186,7 @@ write_register (int regnum, LONGEST val) { void *buf; int size; - size = REGISTER_RAW_SIZE (regnum); + size = DEPRECATED_REGISTER_RAW_SIZE (regnum); buf = alloca (size); store_signed_integer (buf, size, (LONGEST) val); deprecated_write_register_gen (regnum, buf); @@ -1551,7 +1552,7 @@ regcache_dump (struct regcache *regcache, struct ui_file *file, fprintf_unfiltered (file, " %5ld", regcache->descr->sizeof_register[regnum]); if ((regcache->descr->sizeof_register[regnum] - != REGISTER_RAW_SIZE (regnum)) + != DEPRECATED_REGISTER_RAW_SIZE (regnum)) || (regcache->descr->sizeof_register[regnum] != DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum)) || (regcache->descr->sizeof_register[regnum] @@ -1609,7 +1610,7 @@ regcache_dump (struct regcache *regcache, struct ui_file *file, regcache_raw_read (regcache, regnum, buf); fprintf_unfiltered (file, "0x"); dump_endian_bytes (file, TARGET_BYTE_ORDER, buf, - REGISTER_RAW_SIZE (regnum)); + DEPRECATED_REGISTER_RAW_SIZE (regnum)); } } diff --git a/gdb/remote-e7000.c b/gdb/remote-e7000.c index 94985fe5816..d95590d0f74 100644 --- a/gdb/remote-e7000.c +++ b/gdb/remote-e7000.c @@ -882,7 +882,7 @@ fetch_regs_from_dump (int (*nextchar) (), char *want) internal_error (__FILE__, __LINE__, "failed internal consistency check"); } store_signed_integer (buf, - REGISTER_RAW_SIZE (regno), + DEPRECATED_REGISTER_RAW_SIZE (regno), (LONGEST) get_hex (&thischar)); supply_register (regno, buf); break; @@ -1964,7 +1964,7 @@ sub2_from_pc (void) char buf2[200]; store_signed_integer (buf, - REGISTER_RAW_SIZE (PC_REGNUM), + DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM), read_register (PC_REGNUM) - 2); supply_register (PC_REGNUM, buf); sprintf (buf2, ".PC %s\r", phex_nz (read_register (PC_REGNUM), 0)); diff --git a/gdb/remote-mips.c b/gdb/remote-mips.c index 3dc3601443b..c9a7ddfed10 100644 --- a/gdb/remote-mips.c +++ b/gdb/remote-mips.c @@ -1793,16 +1793,16 @@ mips_wait (ptid_t ptid, struct target_waitstatus *status) { char buf[MAX_REGISTER_SIZE]; - store_unsigned_integer (buf, REGISTER_RAW_SIZE (PC_REGNUM), rpc); + store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM), rpc); supply_register (PC_REGNUM, buf); - store_unsigned_integer (buf, REGISTER_RAW_SIZE (PC_REGNUM), rfp); + store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM), rfp); supply_register (30, buf); /* This register they are avoiding and so it is unnamed */ - store_unsigned_integer (buf, REGISTER_RAW_SIZE (SP_REGNUM), rsp); + store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (SP_REGNUM), rsp); supply_register (SP_REGNUM, buf); - store_unsigned_integer (buf, REGISTER_RAW_SIZE (DEPRECATED_FP_REGNUM), 0); + store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (DEPRECATED_FP_REGNUM), 0); supply_register (DEPRECATED_FP_REGNUM, buf); if (nfields == 9) @@ -1976,7 +1976,7 @@ mips_fetch_registers (int regno) /* We got the number the register holds, but gdb expects to see a value in the target byte ordering. */ - store_unsigned_integer (buf, REGISTER_RAW_SIZE (regno), val); + store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regno), val); supply_register (regno, buf); } } diff --git a/gdb/remote-sim.c b/gdb/remote-sim.c index 11424bb81ea..538f8a4dbc1 100644 --- a/gdb/remote-sim.c +++ b/gdb/remote-sim.c @@ -320,14 +320,14 @@ gdbsim_fetch_register (int regno) memset (buf, 0, MAX_REGISTER_SIZE); nr_bytes = sim_fetch_register (gdbsim_desc, REGISTER_SIM_REGNO (regno), - buf, REGISTER_RAW_SIZE (regno)); - if (nr_bytes > 0 && nr_bytes != REGISTER_RAW_SIZE (regno) && warn_user) + buf, DEPRECATED_REGISTER_RAW_SIZE (regno)); + if (nr_bytes > 0 && nr_bytes != DEPRECATED_REGISTER_RAW_SIZE (regno) && warn_user) { fprintf_unfiltered (gdb_stderr, "Size of register %s (%d/%d) incorrect (%d instead of %d))", REGISTER_NAME (regno), regno, REGISTER_SIM_REGNO (regno), - nr_bytes, REGISTER_RAW_SIZE (regno)); + nr_bytes, DEPRECATED_REGISTER_RAW_SIZE (regno)); warn_user = 0; } /* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0' @@ -340,7 +340,7 @@ gdbsim_fetch_register (int regno) { printf_filtered ("gdbsim_fetch_register: %d", regno); /* FIXME: We could print something more intelligible. */ - dump_mem (buf, REGISTER_RAW_SIZE (regno)); + dump_mem (buf, DEPRECATED_REGISTER_RAW_SIZE (regno)); } break; } @@ -364,8 +364,8 @@ gdbsim_store_register (int regno) deprecated_read_register_gen (regno, tmp); nr_bytes = sim_store_register (gdbsim_desc, REGISTER_SIM_REGNO (regno), - tmp, REGISTER_RAW_SIZE (regno)); - if (nr_bytes > 0 && nr_bytes != REGISTER_RAW_SIZE (regno)) + tmp, DEPRECATED_REGISTER_RAW_SIZE (regno)); + if (nr_bytes > 0 && nr_bytes != DEPRECATED_REGISTER_RAW_SIZE (regno)) internal_error (__FILE__, __LINE__, "Register size different to expected"); /* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0' @@ -375,7 +375,7 @@ gdbsim_store_register (int regno) { printf_filtered ("gdbsim_store_register: %d", regno); /* FIXME: We could print something more intelligible. */ - dump_mem (tmp, REGISTER_RAW_SIZE (regno)); + dump_mem (tmp, DEPRECATED_REGISTER_RAW_SIZE (regno)); } } } diff --git a/gdb/remote-vxmips.c b/gdb/remote-vxmips.c index 861ef6814e8..6cc7ca5b60b 100644 --- a/gdb/remote-vxmips.c +++ b/gdb/remote-vxmips.c @@ -131,20 +131,20 @@ vx_read_register (int regno) bcopy (&mips_fpreg_packet[MIPS_R_FP0], &deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)], - REGISTER_RAW_SIZE (FP0_REGNUM) * 32); + DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM) * 32); /* Copy the floating point control/status register (fpcsr). */ bcopy (&mips_fpreg_packet[MIPS_R_FPCSR], &deprecated_registers[DEPRECATED_REGISTER_BYTE (FCRCS_REGNUM)], - REGISTER_RAW_SIZE (FCRCS_REGNUM)); + DEPRECATED_REGISTER_RAW_SIZE (FCRCS_REGNUM)); } else { memset (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)], - 0, REGISTER_RAW_SIZE (FP0_REGNUM) * 32); + 0, DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM) * 32); memset (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FCRCS_REGNUM)], - 0, REGISTER_RAW_SIZE (FCRCS_REGNUM)); + 0, DEPRECATED_REGISTER_RAW_SIZE (FCRCS_REGNUM)); } /* Mark the register cache valid. */ @@ -187,13 +187,13 @@ vx_write_register (int regno) bcopy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)], &mips_fpreg_packet[MIPS_R_FP0], - REGISTER_RAW_SIZE (FP0_REGNUM) * 32); + DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM) * 32); /* Copy the floating point control/status register (fpcsr). */ bcopy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FCRCS_REGNUM)], &mips_fpreg_packet[MIPS_R_FPCSR], - REGISTER_RAW_SIZE (FCRCS_REGNUM)); + DEPRECATED_REGISTER_RAW_SIZE (FCRCS_REGNUM)); net_write_registers (mips_fpreg_packet, MIPS_FPREG_PLEN, PTRACE_SETFPREGS); diff --git a/gdb/remote-vxsparc.c b/gdb/remote-vxsparc.c index c43db2645d8..d313c8f133b 100644 --- a/gdb/remote-vxsparc.c +++ b/gdb/remote-vxsparc.c @@ -102,9 +102,9 @@ vx_read_register (int regno) automatically; it greatly simplifies debugging. */ sp = extract_unsigned_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (SP_REGNUM)], - REGISTER_RAW_SIZE (SP_REGNUM)); + DEPRECATED_REGISTER_RAW_SIZE (SP_REGNUM)); write_memory (sp, &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)], - 16 * REGISTER_RAW_SIZE (L0_REGNUM)); + 16 * DEPRECATED_REGISTER_RAW_SIZE (L0_REGNUM)); /* If the target has floating point registers, fetch them. Otherwise, zero the floating point register values in @@ -177,9 +177,9 @@ vx_write_register (int regno) if (regno < 0 || (L0_REGNUM <= regno && regno <= I7_REGNUM)) { sp = extract_unsigned_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (SP_REGNUM)], - REGISTER_RAW_SIZE (SP_REGNUM)); + DEPRECATED_REGISTER_RAW_SIZE (SP_REGNUM)); write_memory (sp, &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)], - 16 * REGISTER_RAW_SIZE (L0_REGNUM)); + 16 * DEPRECATED_REGISTER_RAW_SIZE (L0_REGNUM)); } } diff --git a/gdb/remote.c b/gdb/remote.c index 0a108731faf..3d24684a318 100644 --- a/gdb/remote.c +++ b/gdb/remote.c @@ -216,7 +216,7 @@ struct packet_reg long regnum; /* GDB's internal register number. */ LONGEST pnum; /* Remote protocol register number. */ int in_g_packet; /* Always part of G packet. */ - /* long size in bytes; == REGISTER_RAW_SIZE (regnum); at present. */ + /* long size in bytes; == DEPRECATED_REGISTER_RAW_SIZE (regnum); at present. */ /* char *name; == REGISTER_NAME (regnum); at present. */ }; @@ -3023,9 +3023,9 @@ Packet: '%s'\n", error ("Remote sent bad register number %s: %s\nPacket: '%s'\n", phex_nz (pnum, 0), p, buf); - fieldsize = hex2bin (p, regs, REGISTER_RAW_SIZE (reg->regnum)); + fieldsize = hex2bin (p, regs, DEPRECATED_REGISTER_RAW_SIZE (reg->regnum)); p += 2 * fieldsize; - if (fieldsize < REGISTER_RAW_SIZE (reg->regnum)) + if (fieldsize < DEPRECATED_REGISTER_RAW_SIZE (reg->regnum)) warning ("Remote reply is too short: %s", buf); supply_register (reg->regnum, regs); } @@ -3271,9 +3271,9 @@ remote_async_wait (ptid_t ptid, struct target_waitstatus *status) error ("Remote sent bad register number %ld: %s\nPacket: '%s'\n", pnum, p, buf); - fieldsize = hex2bin (p, regs, REGISTER_RAW_SIZE (reg->regnum)); + fieldsize = hex2bin (p, regs, DEPRECATED_REGISTER_RAW_SIZE (reg->regnum)); p += 2 * fieldsize; - if (fieldsize < REGISTER_RAW_SIZE (reg->regnum)) + if (fieldsize < DEPRECATED_REGISTER_RAW_SIZE (reg->regnum)) warning ("Remote reply is too short: %s", buf); supply_register (reg->regnum, regs); } @@ -3548,7 +3548,7 @@ store_register_using_P (int regnum) sprintf (buf, "P%s=", phex_nz (reg->pnum, 0)); p = buf + strlen (buf); regcache_collect (reg->regnum, regp); - bin2hex (regp, p, REGISTER_RAW_SIZE (reg->regnum)); + bin2hex (regp, p, DEPRECATED_REGISTER_RAW_SIZE (reg->regnum)); remote_send (buf, rs->remote_packet_size); return buf[0] != '\0'; diff --git a/gdb/rom68k-rom.c b/gdb/rom68k-rom.c index af5e02365ed..2ddba0acf5b 100644 --- a/gdb/rom68k-rom.c +++ b/gdb/rom68k-rom.c @@ -101,7 +101,7 @@ rom68k_supply_one_register (int regno, unsigned char *hex) while (is_whitespace (*hex)) hex++; - store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), value); + store_unsigned_integer (regbuf, DEPRECATED_REGISTER_RAW_SIZE (regno), value); supply_register (regno, regbuf); return hex; diff --git a/gdb/rs6000-nat.c b/gdb/rs6000-nat.c index 0c7c122f58b..ad8cc0dc5f3 100644 --- a/gdb/rs6000-nat.c +++ b/gdb/rs6000-nat.c @@ -71,7 +71,7 @@ #ifndef ARCH3264 # define ARCH64() 0 #else -# define ARCH64() (REGISTER_RAW_SIZE (0) == 8) +# define ARCH64() (DEPRECATED_REGISTER_RAW_SIZE (0) == 8) #endif /* Union of 32-bit and 64-bit ".reg" core file sections. */ @@ -251,7 +251,7 @@ fetch_register (int regno) even if the register is really only 32 bits. */ long long buf; rs6000_ptrace64 (PT_READ_GPR, PIDGET (inferior_ptid), nr, 0, (int *)&buf); - if (REGISTER_RAW_SIZE (regno) == 8) + if (DEPRECATED_REGISTER_RAW_SIZE (regno) == 8) memcpy (addr, &buf, 8); else *addr = buf; @@ -320,7 +320,7 @@ store_register (int regno) /* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte area, even if the register is really only 32 bits. */ long long buf; - if (REGISTER_RAW_SIZE (regno) == 8) + if (DEPRECATED_REGISTER_RAW_SIZE (regno) == 8) memcpy (&buf, addr, 8); else buf = *addr; diff --git a/gdb/rs6000-tdep.c b/gdb/rs6000-tdep.c index d638587b696..deb555521df 100644 --- a/gdb/rs6000-tdep.c +++ b/gdb/rs6000-tdep.c @@ -1154,7 +1154,7 @@ rs6000_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr, for (argno = 0, argbytes = 0; argno < nargs && ii < 8; ++ii) { - int reg_size = REGISTER_RAW_SIZE (ii + 3); + int reg_size = DEPRECATED_REGISTER_RAW_SIZE (ii + 3); arg = args[argno]; type = check_typedef (VALUE_TYPE (arg)); @@ -1334,7 +1334,7 @@ e500_extract_return_value (struct type *valtype, struct regcache *regbuf, void * is a pseudo register. */ int offset = 0; int return_regnum = tdep->ppc_gp0_regnum + 3; - int reg_size = REGISTER_RAW_SIZE (return_regnum); + int reg_size = DEPRECATED_REGISTER_RAW_SIZE (return_regnum); int reg_part_size; char *val_buffer; int copied = 0; @@ -1360,7 +1360,7 @@ e500_extract_return_value (struct type *valtype, struct regcache *regbuf, void * if the value is smaller than the register. */ while (copied < vallen) { - reg_part_size = REGISTER_RAW_SIZE (return_regnum + i); + reg_part_size = DEPRECATED_REGISTER_RAW_SIZE (return_regnum + i); /* It is a pseudo/cooked register. */ regcache_cooked_read (regbuf, return_regnum + i, val_buffer + copied); @@ -1421,8 +1421,8 @@ rs6000_extract_return_value (struct type *valtype, char *regbuf, char *valbuf) { /* return value is copied starting from r3. */ if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG - && TYPE_LENGTH (valtype) < REGISTER_RAW_SIZE (3)) - offset = REGISTER_RAW_SIZE (3) - TYPE_LENGTH (valtype); + && TYPE_LENGTH (valtype) < DEPRECATED_REGISTER_RAW_SIZE (3)) + offset = DEPRECATED_REGISTER_RAW_SIZE (3) - TYPE_LENGTH (valtype); memcpy (valbuf, regbuf + DEPRECATED_REGISTER_BYTE (3) + offset, @@ -1700,7 +1700,7 @@ frame_get_saved_regs (struct frame_info *fi, struct rs6000_framedata *fdatap) for (i = fdatap->saved_vr; i < 32; i++) { deprecated_get_frame_saved_regs (fi)[tdep->ppc_vr0_regnum + i] = vr_addr; - vr_addr += REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum); + vr_addr += DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum); } } } @@ -1717,7 +1717,7 @@ frame_get_saved_regs (struct frame_info *fi, struct rs6000_framedata *fdatap) { deprecated_get_frame_saved_regs (fi)[tdep->ppc_ev0_regnum + i] = ev_addr; deprecated_get_frame_saved_regs (fi)[tdep->ppc_gp0_regnum + i] = ev_addr + 4; - ev_addr += REGISTER_RAW_SIZE (tdep->ppc_ev0_regnum); + ev_addr += DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_ev0_regnum); } } } @@ -1782,7 +1782,7 @@ frame_initial_stack_address (struct frame_info *fi) { get_frame_extra_info (fi)->initial_sp = extract_unsigned_integer (tmpbuf, - REGISTER_RAW_SIZE (fdata.alloca_reg)); + DEPRECATED_REGISTER_RAW_SIZE (fdata.alloca_reg)); } else /* NOTE: cagney/2002-04-17: At present the only time @@ -1932,13 +1932,13 @@ static void rs6000_register_convert_to_virtual (int n, struct type *type, char *from, char *to) { - if (TYPE_LENGTH (type) != REGISTER_RAW_SIZE (n)) + if (TYPE_LENGTH (type) != DEPRECATED_REGISTER_RAW_SIZE (n)) { - double val = deprecated_extract_floating (from, 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, REGISTER_RAW_SIZE (n)); + memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (n)); } /* Convert data from virtual format with type TYPE in buffer FROM @@ -1948,13 +1948,13 @@ static void rs6000_register_convert_to_raw (struct type *type, int n, const char *from, char *to) { - if (TYPE_LENGTH (type) != REGISTER_RAW_SIZE (n)) + if (TYPE_LENGTH (type) != DEPRECATED_REGISTER_RAW_SIZE (n)) { double val = deprecated_extract_floating (from, TYPE_LENGTH (type)); - deprecated_store_floating (to, REGISTER_RAW_SIZE (n), val); + deprecated_store_floating (to, DEPRECATED_REGISTER_RAW_SIZE (n), val); } else - memcpy (to, from, REGISTER_RAW_SIZE (n)); + memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (n)); } static void @@ -2060,7 +2060,7 @@ e500_store_return_value (struct type *type, char *valbuf) while (copied < len) { int regnum = gdbarch_tdep (current_gdbarch)->ppc_gp0_regnum + 3 + i; - int reg_size = REGISTER_RAW_SIZE (regnum); + int reg_size = DEPRECATED_REGISTER_RAW_SIZE (regnum); char *reg_val_buf = alloca (reg_size); memcpy (reg_val_buf, valbuf + copied, reg_size); diff --git a/gdb/s390-tdep.c b/gdb/s390-tdep.c index a918148e8e7..28efe437904 100644 --- a/gdb/s390-tdep.c +++ b/gdb/s390-tdep.c @@ -2000,7 +2000,7 @@ s390_pop_frame_regular (struct frame_info *frame) ULONGEST value; value = read_memory_unsigned_integer (deprecated_get_frame_saved_regs (frame)[regnum], - REGISTER_RAW_SIZE (regnum)); + DEPRECATED_REGISTER_RAW_SIZE (regnum)); write_register (regnum, value); } diff --git a/gdb/sh64-tdep.c b/gdb/sh64-tdep.c index ae76ee9a5e9..5188cfd8e1d 100644 --- a/gdb/sh64-tdep.c +++ b/gdb/sh64-tdep.c @@ -753,7 +753,7 @@ sh64_frame_chain (struct frame_info *frame) if (gdbarch_tdep (current_gdbarch)->sh_abi == SH_ABI_32) size = 4; else - size = REGISTER_RAW_SIZE (translate_insn_rn (DEPRECATED_FP_REGNUM, media_mode)); + size = DEPRECATED_REGISTER_RAW_SIZE (translate_insn_rn (DEPRECATED_FP_REGNUM, media_mode)); return read_memory_integer (get_frame_base (frame) + get_frame_extra_info (frame)->f_offset, size); @@ -787,7 +787,7 @@ sh64_get_saved_pr (struct frame_info *fi, int pr_regnum) int gdb_reg_num = translate_insn_rn (pr_regnum, media_mode); int size = ((gdbarch_tdep (current_gdbarch)->sh_abi == SH_ABI_32) ? 4 - : REGISTER_RAW_SIZE (gdb_reg_num)); + : DEPRECATED_REGISTER_RAW_SIZE (gdb_reg_num)); return read_memory_integer (deprecated_get_frame_saved_regs (fi)[pr_regnum], size); } } @@ -1205,7 +1205,7 @@ sh64_nofp_frame_init_saved_regs (struct frame_info *fi) if (tdep->sh_abi == SH_ABI_32) size = 4; else - size = REGISTER_RAW_SIZE (fp_regnum); + size = DEPRECATED_REGISTER_RAW_SIZE (fp_regnum); deprecated_get_frame_saved_regs (fi)[sp_regnum] = read_memory_integer (deprecated_get_frame_saved_regs (fi)[fp_regnum], size); } else @@ -1293,7 +1293,7 @@ sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp, memcpy (raw_buffer, (deprecated_generic_find_dummy_frame (get_frame_pc (frame), get_frame_base (frame)) + DEPRECATED_REGISTER_BYTE (regnum)), - REGISTER_RAW_SIZE (regnum)); + DEPRECATED_REGISTER_RAW_SIZE (regnum)); return; } @@ -1306,7 +1306,7 @@ sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp, if (regnum == SP_REGNUM) { if (raw_buffer) /* SP register treated specially */ - store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum), + store_unsigned_integer (raw_buffer, DEPRECATED_REGISTER_RAW_SIZE (regnum), deprecated_get_frame_saved_regs (frame)[regnum]); } else @@ -1322,13 +1322,13 @@ sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp, || live_regnum == PR_REGNUM)) size = 4; else - size = REGISTER_RAW_SIZE (live_regnum); + size = DEPRECATED_REGISTER_RAW_SIZE (live_regnum); if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE) read_memory (deprecated_get_frame_saved_regs (frame)[regnum], raw_buffer, size); else read_memory (deprecated_get_frame_saved_regs (frame)[regnum], raw_buffer - + REGISTER_RAW_SIZE (live_regnum) + + DEPRECATED_REGISTER_RAW_SIZE (live_regnum) - size, size); } @@ -1352,7 +1352,7 @@ static CORE_ADDR sh64_extract_struct_value_address (char *regbuf) { return (extract_unsigned_integer ((regbuf + DEPRECATED_REGISTER_BYTE (STRUCT_RETURN_REGNUM)), - REGISTER_RAW_SIZE (STRUCT_RETURN_REGNUM))); + DEPRECATED_REGISTER_RAW_SIZE (STRUCT_RETURN_REGNUM))); } static CORE_ADDR @@ -1392,7 +1392,7 @@ sh64_pop_frame (void) || regnum == PR_REGNUM)) size = 4; else - size = REGISTER_RAW_SIZE (translate_insn_rn (regnum, + size = DEPRECATED_REGISTER_RAW_SIZE (translate_insn_rn (regnum, media_mode)); write_register (regnum, read_memory_integer (deprecated_get_frame_saved_regs (frame)[regnum], @@ -1526,7 +1526,7 @@ sh64_push_arguments (int nargs, struct value **args, CORE_ADDR sp, if (TYPE_CODE (type) != TYPE_CODE_FLT) { - argreg_size = REGISTER_RAW_SIZE (int_argreg); + argreg_size = DEPRECATED_REGISTER_RAW_SIZE (int_argreg); if (len < argreg_size) { @@ -1702,7 +1702,7 @@ sh64_extract_return_value (struct type *type, char *regbuf, char *valbuf) return_register = DEFAULT_RETURN_REGNUM; if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) offset = DEPRECATED_REGISTER_BYTE (return_register) + - REGISTER_RAW_SIZE (return_register) - len; + DEPRECATED_REGISTER_RAW_SIZE (return_register) - len; else offset = DEPRECATED_REGISTER_BYTE (return_register); memcpy (valbuf, (char *) regbuf + offset, len); @@ -1743,14 +1743,14 @@ sh64_store_return_value (struct type *type, char *valbuf) int return_register = DEFAULT_RETURN_REGNUM; int offset = 0; - if (len <= REGISTER_RAW_SIZE (return_register)) + if (len <= DEPRECATED_REGISTER_RAW_SIZE (return_register)) { /* Pad with zeros. */ - memset (buf, 0, REGISTER_RAW_SIZE (return_register)); + memset (buf, 0, DEPRECATED_REGISTER_RAW_SIZE (return_register)); if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE) - offset = 0; /*REGISTER_RAW_SIZE (return_register) - len;*/ + offset = 0; /*DEPRECATED_REGISTER_RAW_SIZE (return_register) - len;*/ else - offset = REGISTER_RAW_SIZE (return_register) - len; + offset = DEPRECATED_REGISTER_RAW_SIZE (return_register) - len; memcpy (buf + offset, valbuf, len); deprecated_write_register_gen (return_register, buf); @@ -2092,7 +2092,7 @@ sh_sh64_register_convert_to_virtual (int regnum, struct type *type, if (TARGET_BYTE_ORDER != BFD_ENDIAN_LITTLE) { /* It is a no-op. */ - memcpy (to, from, REGISTER_RAW_SIZE (regnum)); + memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regnum)); return; } @@ -2118,7 +2118,7 @@ sh_sh64_register_convert_to_raw (struct type *type, int regnum, if (TARGET_BYTE_ORDER != BFD_ENDIAN_LITTLE) { /* It is a no-op. */ - memcpy (to, from, REGISTER_RAW_SIZE (regnum)); + memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regnum)); return; } @@ -2155,7 +2155,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, for (portion = 0; portion < 2; portion++) regcache_raw_read (regcache, base_regnum + portion, (temp_buffer - + REGISTER_RAW_SIZE (base_regnum) * portion)); + + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion)); /* We must pay attention to the endiannes. */ sh_sh64_register_convert_to_virtual (reg_nr, DEPRECATED_REGISTER_VIRTUAL_TYPE (reg_nr), @@ -2174,7 +2174,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, for (portion = 0; portion < 2; portion++) regcache_raw_read (regcache, base_regnum + portion, ((char *) buffer - + REGISTER_RAW_SIZE (base_regnum) * portion)); + + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion)); } else if (reg_nr >= FV0_REGNUM @@ -2188,7 +2188,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, for (portion = 0; portion < 4; portion++) regcache_raw_read (regcache, base_regnum + portion, ((char *) buffer - + REGISTER_RAW_SIZE (base_regnum) * portion)); + + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion)); } /* sh compact pseudo registers. 1-to-1 with a shmedia register */ @@ -2225,7 +2225,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, for (portion = 0; portion < 2; portion++) regcache_raw_read (regcache, base_regnum + portion, (temp_buffer - + REGISTER_RAW_SIZE (base_regnum) * portion)); + + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion)); /* We must pay attention to the endiannes. */ sh_sh64_register_convert_to_virtual (reg_nr, DEPRECATED_REGISTER_VIRTUAL_TYPE (reg_nr), @@ -2243,7 +2243,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, for (portion = 0; portion < 4; portion++) regcache_raw_read (regcache, base_regnum + portion, ((char *) buffer - + REGISTER_RAW_SIZE (base_regnum) * portion)); + + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion)); } else if (reg_nr == FPSCR_C_REGNUM) @@ -2322,7 +2322,7 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, for (portion = 0; portion < 2; portion++) regcache_raw_write (regcache, base_regnum + portion, (temp_buffer - + REGISTER_RAW_SIZE (base_regnum) * portion)); + + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion)); } else if (reg_nr >= FPP0_REGNUM @@ -2334,7 +2334,7 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, for (portion = 0; portion < 2; portion++) regcache_raw_write (regcache, base_regnum + portion, ((char *) buffer - + REGISTER_RAW_SIZE (base_regnum) * portion)); + + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion)); } else if (reg_nr >= FV0_REGNUM @@ -2346,7 +2346,7 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, for (portion = 0; portion < 4; portion++) regcache_raw_write (regcache, base_regnum + portion, ((char *) buffer - + REGISTER_RAW_SIZE (base_regnum) * portion)); + + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion)); } /* sh compact general pseudo registers. 1-to-1 with a shmedia @@ -2390,7 +2390,7 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, regcache_raw_write (regcache, base_regnum + portion, (temp_buffer - + REGISTER_RAW_SIZE (base_regnum) * portion)); + + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion)); } } @@ -2403,7 +2403,7 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, { regcache_raw_write (regcache, base_regnum + portion, ((char *) buffer - + REGISTER_RAW_SIZE (base_regnum) * portion)); + + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion)); } } diff --git a/gdb/sparc-nat.c b/gdb/sparc-nat.c index a4df86507b7..a76d0e546ee 100644 --- a/gdb/sparc-nat.c +++ b/gdb/sparc-nat.c @@ -103,7 +103,7 @@ fetch_inferior_registers (int regno) deprecated_registers[DEPRECATED_REGISTER_BYTE (0)] = 0; memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (1)], - &inferior_registers.r_g1, 15 * REGISTER_RAW_SIZE (G0_REGNUM)); + &inferior_registers.r_g1, 15 * DEPRECATED_REGISTER_RAW_SIZE (G0_REGNUM)); *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps; *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)] @@ -149,7 +149,7 @@ fetch_inferior_registers (int regno) { CORE_ADDR sp = *(unsigned int *) & deprecated_registers[DEPRECATED_REGISTER_BYTE (SP_REGNUM)]; target_read_memory (sp, &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)], - 16 * REGISTER_RAW_SIZE (L0_REGNUM)); + 16 * DEPRECATED_REGISTER_RAW_SIZE (L0_REGNUM)); for (i = L0_REGNUM; i <= I7_REGNUM; i++) deprecated_register_valid[i] = 1; } @@ -160,7 +160,7 @@ fetch_inferior_registers (int regno) if (deprecated_register_valid[regno]) printf_unfiltered ("register %d valid and read\n", regno); target_read_memory (sp + i - DEPRECATED_REGISTER_BYTE (L0_REGNUM), - &deprecated_registers[i], REGISTER_RAW_SIZE (regno)); + &deprecated_registers[i], DEPRECATED_REGISTER_RAW_SIZE (regno)); deprecated_register_valid[regno] = 1; } } @@ -234,7 +234,7 @@ store_inferior_registers (int regno) internal_error (__FILE__, __LINE__, "failed internal consistency check"); target_write_memory (sp, &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)], - 16 * REGISTER_RAW_SIZE (L0_REGNUM)); + 16 * DEPRECATED_REGISTER_RAW_SIZE (L0_REGNUM)); } else { @@ -242,7 +242,7 @@ store_inferior_registers (int regno) internal_error (__FILE__, __LINE__, "failed internal consistency check"); target_write_memory (sp + DEPRECATED_REGISTER_BYTE (regno) - DEPRECATED_REGISTER_BYTE (L0_REGNUM), &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)], - REGISTER_RAW_SIZE (regno)); + DEPRECATED_REGISTER_RAW_SIZE (regno)); } } @@ -254,7 +254,7 @@ store_inferior_registers (int regno) memcpy (&inferior_registers.r_g1, &deprecated_registers[DEPRECATED_REGISTER_BYTE (G1_REGNUM)], - 15 * REGISTER_RAW_SIZE (G1_REGNUM)); + 15 * DEPRECATED_REGISTER_RAW_SIZE (G1_REGNUM)); inferior_registers.r_ps = *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PS_REGNUM)]; @@ -315,7 +315,7 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, /* The globals and output registers. */ memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (G1_REGNUM)], &gregs->r_g1, - 15 * REGISTER_RAW_SIZE (G1_REGNUM)); + 15 * DEPRECATED_REGISTER_RAW_SIZE (G1_REGNUM)); *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PS_REGNUM)] = gregs->r_ps; *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)] = gregs->r_pc; *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (DEPRECATED_NPC_REGNUM)] = gregs->r_npc; @@ -332,7 +332,7 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, sp = *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (SP_REGNUM)]; if (0 != target_read_memory (sp, &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)], - 16 * REGISTER_RAW_SIZE (L0_REGNUM))) + 16 * DEPRECATED_REGISTER_RAW_SIZE (L0_REGNUM))) { /* fprintf_unfiltered so user can still use gdb */ fprintf_unfiltered (gdb_stderr, diff --git a/gdb/sparc-tdep.c b/gdb/sparc-tdep.c index a9417d97671..091d4fbfe23 100644 --- a/gdb/sparc-tdep.c +++ b/gdb/sparc-tdep.c @@ -815,7 +815,7 @@ sparc_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp, if (raw_buffer != NULL) { /* Put it back in target format. */ - store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum), get_frame_pc (frame)); + store_unsigned_integer (raw_buffer, DEPRECATED_REGISTER_RAW_SIZE (regnum), get_frame_pc (frame)); } if (addrp != NULL) *addrp = 0; @@ -923,14 +923,14 @@ sparc_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp, if (raw_buffer != NULL) { /* Put it back in target format. */ - store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum), addr); + store_unsigned_integer (raw_buffer, DEPRECATED_REGISTER_RAW_SIZE (regnum), addr); } if (addrp != NULL) *addrp = 0; return; } if (raw_buffer != NULL) - read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum)); + read_memory (addr, raw_buffer, DEPRECATED_REGISTER_RAW_SIZE (regnum)); } else { @@ -974,10 +974,10 @@ sparc_push_dummy_frame (void) /* PC, NPC, CCR, FSR, FPRS, Y, ASI */ deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (PC_REGNUM), ®ister_temp[0], - REGISTER_RAW_SIZE (PC_REGNUM) * 7); + DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM) * 7); deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (PSTATE_REGNUM), ®ister_temp[7 * SPARC_INTREG_SIZE], - REGISTER_RAW_SIZE (PSTATE_REGNUM)); + DEPRECATED_REGISTER_RAW_SIZE (PSTATE_REGNUM)); /* FIXME: not sure what needs to be saved here. */ } else @@ -985,7 +985,7 @@ sparc_push_dummy_frame (void) /* Y, PS, WIM, TBR, PC, NPC, FPS, CPS regs */ deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (Y_REGNUM), ®ister_temp[0], - REGISTER_RAW_SIZE (Y_REGNUM) * 8); + DEPRECATED_REGISTER_RAW_SIZE (Y_REGNUM) * 8); } deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (O0_REGNUM), @@ -1308,29 +1308,29 @@ sparc_pop_frame (void) if (fsr[PS_REGNUM]) write_register (PS_REGNUM, read_memory_integer (fsr[PS_REGNUM], - REGISTER_RAW_SIZE (PS_REGNUM))); + DEPRECATED_REGISTER_RAW_SIZE (PS_REGNUM))); if (fsr[Y_REGNUM]) write_register (Y_REGNUM, read_memory_integer (fsr[Y_REGNUM], - REGISTER_RAW_SIZE (Y_REGNUM))); + DEPRECATED_REGISTER_RAW_SIZE (Y_REGNUM))); if (fsr[PC_REGNUM]) { /* Explicitly specified PC (and maybe NPC) -- just restore them. */ write_register (PC_REGNUM, read_memory_integer (fsr[PC_REGNUM], - REGISTER_RAW_SIZE (PC_REGNUM))); + DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM))); if (fsr[DEPRECATED_NPC_REGNUM]) write_register (DEPRECATED_NPC_REGNUM, read_memory_integer (fsr[DEPRECATED_NPC_REGNUM], - REGISTER_RAW_SIZE (DEPRECATED_NPC_REGNUM))); + DEPRECATED_REGISTER_RAW_SIZE (DEPRECATED_NPC_REGNUM))); } else if (get_frame_extra_info (frame)->flat) { if (get_frame_extra_info (frame)->pc_addr) pc = PC_ADJUST ((CORE_ADDR) read_memory_integer (get_frame_extra_info (frame)->pc_addr, - REGISTER_RAW_SIZE (PC_REGNUM))); + DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM))); else { /* I think this happens only in the innermost frame, if so then @@ -1713,7 +1713,7 @@ fill_fpregset (gdb_fpregset_t *fpregsetp, int regno) { from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)]; to = (char *) &fpregsetp->pr_fr.pr_regs[regi - FP0_REGNUM]; - memcpy (to, from, REGISTER_RAW_SIZE (regi)); + memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regi)); } } @@ -1722,7 +1722,7 @@ fill_fpregset (gdb_fpregset_t *fpregsetp, int regno) { from = (char *)&deprecated_registers[DEPRECATED_REGISTER_BYTE (FPS_REGNUM)]; to = (char *) &fpregsetp->pr_fsr; - memcpy (to, from, REGISTER_RAW_SIZE (FPS_REGNUM)); + memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (FPS_REGNUM)); } } @@ -2071,13 +2071,13 @@ sparc_print_registers (struct gdbarch *gdbarch, file, 0, 1, 0, Val_pretty_default); fprintf_filtered (file, "\t(raw 0x"); - for (j = 0; j < REGISTER_RAW_SIZE (i); j++) + for (j = 0; j < DEPRECATED_REGISTER_RAW_SIZE (i); j++) { int idx; if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) idx = j; else - idx = REGISTER_RAW_SIZE (i) - 1 - j; + idx = DEPRECATED_REGISTER_RAW_SIZE (i) - 1 - j; fprintf_filtered (file, "%02x", (unsigned char) raw_buffer[idx]); } fprintf_filtered (file, ")"); @@ -2408,10 +2408,10 @@ sparc_store_return_value (struct type *type, char *valbuf) regno = O0_REGNUM; /* Add leading zeros to the value. */ - if (TYPE_LENGTH (type) < REGISTER_RAW_SIZE (regno)) + if (TYPE_LENGTH (type) < DEPRECATED_REGISTER_RAW_SIZE (regno)) { - memset (buffer, 0, REGISTER_RAW_SIZE (regno)); - memcpy (buffer + REGISTER_RAW_SIZE (regno) - TYPE_LENGTH (type), valbuf, + memset (buffer, 0, DEPRECATED_REGISTER_RAW_SIZE (regno)); + memcpy (buffer + DEPRECATED_REGISTER_RAW_SIZE (regno) - TYPE_LENGTH (type), valbuf, TYPE_LENGTH (type)); deprecated_write_register_gen (regno, buffer); } @@ -2722,7 +2722,7 @@ sp64_extract_return_value (struct type *type, char *regbuf, char *valbuf, int bitoffset) { int typelen = TYPE_LENGTH (type); - int regsize = REGISTER_RAW_SIZE (O0_REGNUM); + int regsize = DEPRECATED_REGISTER_RAW_SIZE (O0_REGNUM); if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU) { diff --git a/gdb/stack.c b/gdb/stack.c index ebf439e50e6..c52017c9635 100644 --- a/gdb/stack.c +++ b/gdb/stack.c @@ -1055,7 +1055,7 @@ frame_info (char *addr_exp, int from_tty) /* NOTE: cagney/2003-05-22: This is assuming that the stack pointer was packed as an unsigned integer. That may or may not be valid. */ - sp = extract_unsigned_integer (value, REGISTER_RAW_SIZE (SP_REGNUM)); + sp = extract_unsigned_integer (value, DEPRECATED_REGISTER_RAW_SIZE (SP_REGNUM)); printf_filtered (" Previous frame's sp is "); print_address_numeric (sp, 1, gdb_stdout); printf_filtered ("\n"); diff --git a/gdb/target.c b/gdb/target.c index 7539b3ca660..865cc353ce3 100644 --- a/gdb/target.c +++ b/gdb/target.c @@ -1660,11 +1660,11 @@ debug_print_register (const char * func, int regno) unsigned char buf[MAX_REGISTER_SIZE]; deprecated_read_register_gen (regno, buf); fprintf_unfiltered (gdb_stdlog, " = "); - for (i = 0; i < REGISTER_RAW_SIZE (regno); i++) + for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i++) { fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]); } - if (REGISTER_RAW_SIZE (regno) <= sizeof (LONGEST)) + if (DEPRECATED_REGISTER_RAW_SIZE (regno) <= sizeof (LONGEST)) { fprintf_unfiltered (gdb_stdlog, " 0x%s %s", paddr_nz (read_register (regno)), diff --git a/gdb/tracepoint.c b/gdb/tracepoint.c index 6cb632370cb..5c85db444be 100644 --- a/gdb/tracepoint.c +++ b/gdb/tracepoint.c @@ -1215,7 +1215,7 @@ collect_symbol (struct collection_list *collect, struct symbol *sym, /* check for doubles stored in two registers */ /* FIXME: how about larger types stored in 3 or more regs? */ if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT && - len > REGISTER_RAW_SIZE (reg)) + len > DEPRECATED_REGISTER_RAW_SIZE (reg)) add_register (collect, reg + 1); break; case LOC_REF_ARG: diff --git a/gdb/tui/ChangeLog b/gdb/tui/ChangeLog index 68386a49786..fc5886c1ae1 100644 --- a/gdb/tui/ChangeLog +++ b/gdb/tui/ChangeLog @@ -1,3 +1,8 @@ +2003-09-27 Andrew Cagney <cagney@redhat.com> + + * tuiRegs.c: Rename REGISTER_RAW_SIZE to + DEPRECATED_REGISTER_RAW_SIZE. + 2003-09-13 Andrew Cagney <cagney@redhat.com> * tui.h (struct ui_file): Add opaque declaration. diff --git a/gdb/tui/tuiRegs.c b/gdb/tui/tuiRegs.c index 1c8ba9a9601..3a0c4590c8c 100644 --- a/gdb/tui/tuiRegs.c +++ b/gdb/tui/tuiRegs.c @@ -500,7 +500,7 @@ tuiCheckRegisterValues (struct frame_info *frame) { int size; - size = REGISTER_RAW_SIZE (dataElementPtr->itemNo); + size = DEPRECATED_REGISTER_RAW_SIZE (dataElementPtr->itemNo); for (j = 0; j < size; j++) ((char *) dataElementPtr->value)[j] = rawBuf[j]; _tuiDisplayRegister ( @@ -763,7 +763,7 @@ _tuiRegValueHasChanged (TuiDataElementPtr dataElement, if (_tuiGetRegisterRawValue ( dataElement->itemNo, rawBuf, frame) == TUI_SUCCESS) { - int size = REGISTER_RAW_SIZE (dataElement->itemNo); + int size = DEPRECATED_REGISTER_RAW_SIZE (dataElement->itemNo); for (i = 0; (i < size && !hasChanged); i++) hasChanged = (((char *) dataElement->value)[i] != rawBuf[i]); diff --git a/gdb/v850-tdep.c b/gdb/v850-tdep.c index 27730d539ea..a9ca9ddd75e 100644 --- a/gdb/v850-tdep.c +++ b/gdb/v850-tdep.c @@ -1074,7 +1074,7 @@ v850_extract_return_value (struct type *type, char *regbuf, char *valbuf) pointed to by R6. */ return_buffer = extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (E_V0_REGNUM), - REGISTER_RAW_SIZE (E_V0_REGNUM)); + DEPRECATED_REGISTER_RAW_SIZE (E_V0_REGNUM)); read_memory (return_buffer, valbuf, TYPE_LENGTH (type)); } diff --git a/gdb/v850ice.c b/gdb/v850ice.c index e0331fa5d3a..9f516a32d91 100644 --- a/gdb/v850ice.c +++ b/gdb/v850ice.c @@ -534,7 +534,7 @@ v850ice_fetch_registers (int regno) error ("v850ice_fetch_registers (%d): bad value from ICE: %s.", regno, val); - store_unsigned_integer (val, REGISTER_RAW_SIZE (regno), regval); + store_unsigned_integer (val, DEPRECATED_REGISTER_RAW_SIZE (regno), regval); supply_register (regno, val); } @@ -560,7 +560,7 @@ v850ice_store_registers (int regno) } regval = extract_unsigned_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)], - REGISTER_RAW_SIZE (regno)); + DEPRECATED_REGISTER_RAW_SIZE (regno)); strcpy (cmd, "reg "); if (!convert_register (regno, &cmd[4])) return; diff --git a/gdb/valops.c b/gdb/valops.c index 08036de5e2c..e037441a925 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -627,7 +627,7 @@ value_assign (struct value *toval, struct value *fromval) { int offset; for (reg_offset = value_reg, offset = 0; - offset + REGISTER_RAW_SIZE (reg_offset) <= VALUE_OFFSET (toval); + offset + DEPRECATED_REGISTER_RAW_SIZE (reg_offset) <= VALUE_OFFSET (toval); reg_offset++); byte_offset = VALUE_OFFSET (toval) - offset; } @@ -645,7 +645,7 @@ value_assign (struct value *toval, struct value *fromval) /* Copy it in. */ for (regno = reg_offset, amount_copied = 0; amount_copied < amount_to_copy; - amount_copied += REGISTER_RAW_SIZE (regno), regno++) + amount_copied += DEPRECATED_REGISTER_RAW_SIZE (regno), regno++) frame_register_read (frame, regno, buffer + amount_copied); /* Modify what needs to be modified. */ @@ -662,7 +662,7 @@ value_assign (struct value *toval, struct value *fromval) /* Copy it out. */ for (regno = reg_offset, amount_copied = 0; amount_copied < amount_to_copy; - amount_copied += REGISTER_RAW_SIZE (regno), regno++) + amount_copied += DEPRECATED_REGISTER_RAW_SIZE (regno), regno++) put_frame_register (frame, regno, buffer + amount_copied); } diff --git a/gdb/vax-tdep.c b/gdb/vax-tdep.c index 1d90234109d..5c99aa859d9 100644 --- a/gdb/vax-tdep.c +++ b/gdb/vax-tdep.c @@ -280,7 +280,7 @@ static CORE_ADDR vax_extract_struct_value_address (char *regbuf) { return (extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (0), - REGISTER_RAW_SIZE (0))); + DEPRECATED_REGISTER_RAW_SIZE (0))); } static const unsigned char * diff --git a/gdb/vax-tdep.h b/gdb/vax-tdep.h index e81caed4a5e..1a19917740a 100644 --- a/gdb/vax-tdep.h +++ b/gdb/vax-tdep.h @@ -22,7 +22,7 @@ #define VAX_TDEP_H /* Say how long (ordinary) registers are. This is a piece of bogosity - used in push_word and a few other places; REGISTER_RAW_SIZE is the + used in push_word and a few other places; DEPRECATED_REGISTER_RAW_SIZE is the real way to know how big a register is. */ #define VAX_REGISTER_SIZE 4 @@ -33,7 +33,7 @@ register state. */ #define VAX_REGISTER_BYTES (VAX_NUM_REGS * 4) -/* Largest value REGISTER_RAW_SIZE can have. */ +/* Largest value DEPRECATED_REGISTER_RAW_SIZE can have. */ #define VAX_MAX_REGISTER_RAW_SIZE 4 /* Largest value DEPRECATED_REGISTER_VIRTUAL_SIZE can have. */ diff --git a/gdb/x86-64-tdep.c b/gdb/x86-64-tdep.c index 39a02b05ed3..ddba4dbf3e4 100644 --- a/gdb/x86-64-tdep.c +++ b/gdb/x86-64-tdep.c @@ -795,8 +795,8 @@ x86_64_store_return_value (struct type *type, struct regcache *regcache, /* XXX: What about complex floating point types? */ else { - int low_size = REGISTER_RAW_SIZE (0); - int high_size = REGISTER_RAW_SIZE (1); + int low_size = DEPRECATED_REGISTER_RAW_SIZE (0); + int high_size = DEPRECATED_REGISTER_RAW_SIZE (1); if (len <= low_size) regcache_cooked_write_part (regcache, 0, 0, len, valbuf); diff --git a/gdb/xstormy16-tdep.c b/gdb/xstormy16-tdep.c index 544cdc8daf3..e4bebc875da 100644 --- a/gdb/xstormy16-tdep.c +++ b/gdb/xstormy16-tdep.c @@ -230,7 +230,7 @@ xstormy16_extract_return_value (struct type *type, char *regbuf, char *valbuf) pointed to by R2. */ return_buffer = extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (E_PTR_RET_REGNUM), - REGISTER_RAW_SIZE (E_PTR_RET_REGNUM)); + DEPRECATED_REGISTER_RAW_SIZE (E_PTR_RET_REGNUM)); read_memory (return_buffer, valbuf, TYPE_LENGTH (type)); } |