FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

2003-10-02 Andrew Cagney <cagney@redhat.com>

Browse source 
* 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  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-10-02  Andrew Cagney  <cagney@redhat.com>

	* mi-main.c: Rename REGISTER_RAW_SIZE to
	DEPRECATED_REGISTER_RAW_SIZE.
This commit is contained in:
Andrew Cagney 2003-10-02 20:28:31 +00:00
parent e3b1168e9d
commit 12c266ea56
69 changed files with 408 additions and 363 deletions
Download patch file Download diff file Expand all files Collapse all files

22
gdb/ChangeLog
View file

@ -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> 2003-10-02 Jim Blandy <jimb@redhat.com>
* dwarf2read.c (struct die_info): Doc fix. * dwarf2read.c (struct die_info): Doc fix.

6
gdb/aix-thread.c
View file

@ -852,7 +852,7 @@ pd_enable (void)
return; return;
/* Check application word size. */ /* Check application word size. */
arch64 = REGISTER_RAW_SIZE (0) == 8; arch64 = DEPRECATED_REGISTER_RAW_SIZE (0) == 8;
/* Check whether the application is pthreaded. */ /* Check whether the application is pthreaded. */
stub_name = NULL; 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 they're not, then either GDB has been built incorrectly, or
there's some other kind of internal error. To be really safe, there's some other kind of internal error. To be really safe,
we should check all of the sizes. */ 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)) if (register_cached (PC_REGNUM))
regcache_collect (PC_REGNUM, iar); 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 built incorrectly. In order to make use of many of the header
files in /usr/include/sys, GDB needs to be configured so that files in /usr/include/sys, GDB needs to be configured so that
sizeof (long) == 4). */ 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)) if (register_cached (PC_REGNUM))
regcache_collect (PC_REGNUM, iar); regcache_collect (PC_REGNUM, iar);

5
gdb/alpha-tdep.h
View file

@ -23,8 +23,9 @@
#define ALPHA_TDEP_H #define ALPHA_TDEP_H
/* Say how long (ordinary) registers are. This is a piece of bogosity /* 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;
real way to know how big a register is. */ DEPRECATED_REGISTER_RAW_SIZE is the real way to know how big a
register is. */
#define ALPHA_REGISTER_SIZE 8 #define ALPHA_REGISTER_SIZE 8
/* Number of machine registers. */ /* Number of machine registers. */

2
gdb/arm-tdep.c
View file

@ -1103,7 +1103,7 @@ arm_make_sigtramp_cache (struct frame_info *next_frame)
cache->framereg = ARM_SP_REGNUM; cache->framereg = ARM_SP_REGNUM;
cache->prev_sp cache->prev_sp
= read_memory_integer (cache->saved_regs[cache->framereg].addr, = read_memory_integer (cache->saved_regs[cache->framereg].addr,
REGISTER_RAW_SIZE (cache->framereg)); DEPRECATED_REGISTER_RAW_SIZE (cache->framereg));
return cache; return cache;
} }

4
gdb/config/m68k/tm-delta68.h
View file

@ -68,10 +68,10 @@ struct frame_info;
#define DEPRECATED_STORE_RETURN_VALUE(TYPE,VALBUF) \ #define DEPRECATED_STORE_RETURN_VALUE(TYPE,VALBUF) \
if (TYPE_CODE (TYPE) == TYPE_CODE_FLT) \ 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_REGISTER_CONVERT_TO_RAW (TYPE, FP0_REGNUM, VALBUF, raw_buf); \
deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (FP0_REGNUM), \ 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 \ else \
deprecated_write_register_bytes ((TYPE_CODE(TYPE) == TYPE_CODE_PTR ? 8 * 4 : 0), \ deprecated_write_register_bytes ((TYPE_CODE(TYPE) == TYPE_CODE_PTR ? 8 * 4 : 0), \

2
gdb/config/m68k/tm-vx68.h
View file

@ -78,5 +78,5 @@
/* Number of registers in a ptrace_getfpregs call. */ /* 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)) + (3 * DEPRECATED_REGISTER_SIZE))

2
gdb/config/sparc/tm-sparc.h
View file

@ -223,7 +223,7 @@ extern void sparc_print_extra_frame_info (struct frame_info *);
address). Some vendors get it wrong. */ address). Some vendors get it wrong. */
#define FRAME_SAVED_L0 0 #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)) #define FRAME_STRUCT_ARGS_ADDRESS(FI) (get_frame_base (FI))

2
gdb/config/sparc/tm-sparclynx.h
View file

@ -32,6 +32,6 @@
#undef FRAME_SAVED_L0 #undef FRAME_SAVED_L0
#define FRAME_SAVED_I0 0 #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 */ #endif /* TM_SPARCLYNX_H */

4
gdb/core-sol2.c
View file

@ -98,7 +98,7 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which,
/* The globals and output registers. */ /* The globals and output registers. */
memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (G1_REGNUM)], 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)] *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PS_REGNUM)]
= gregs->r_ps; = gregs->r_ps;
*(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)] *(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)]; sp = *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (SP_REGNUM)];
if (0 != target_read_memory (sp, if (0 != target_read_memory (sp,
&deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)], &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"); warning ("couldn't read input and local registers from core file\n");
} }

9
gdb/cris-tdep.c
View file

@ -1224,7 +1224,7 @@ cris_init_extra_frame_info (int fromleaf, struct frame_info *fi)
/* SRP was saved on the stack; non-leaf function. */ /* SRP was saved on the stack; non-leaf function. */
get_frame_extra_info (fi)->return_pc = get_frame_extra_info (fi)->return_pc =
read_memory_integer (deprecated_get_frame_saved_regs (fi)[SRP_REGNUM], read_memory_integer (deprecated_get_frame_saved_regs (fi)[SRP_REGNUM],
REGISTER_RAW_SIZE (SRP_REGNUM)); DEPRECATED_REGISTER_RAW_SIZE (SRP_REGNUM));
} }
else else
{ {
@ -4184,8 +4184,9 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_register_name (gdbarch, cris_register_name); set_gdbarch_register_name (gdbarch, cris_register_name);
/* Length of ordinary registers used in push_word and a few other places. /* Length of ordinary registers used in push_word and a few other
REGISTER_RAW_SIZE is the real way to know how big a register is. */ places. DEPRECATED_REGISTER_RAW_SIZE is the real way to know how
big a register is. */
set_gdbarch_deprecated_register_size (gdbarch, 4); set_gdbarch_deprecated_register_size (gdbarch, 4);
/* NEW */ /* 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. */ /* The length of the registers in the actual machine representation. */
set_gdbarch_deprecated_register_raw_size (gdbarch, cris_register_size); 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); set_gdbarch_deprecated_max_register_raw_size (gdbarch, 32);
/* The length of the registers in the program's representation. */ /* The length of the registers in the program's representation. */

8
gdb/doc/ChangeLog
View file

@ -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 * 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. REGISTER_VIRTUAL_SIZE to DEPRECATED_REGISTER_VIRTUAL_SIZE.
(Target Architecture Definition): (Target Architecture Definition):

19
gdb/doc/gdb.texinfo
View file

@ -19517,9 +19517,9 @@ Reply:
Each byte of register data is described by two hex digits. The bytes 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 with the register are transmitted in target byte order. The size of
each register and their position within the @samp{g} @var{packet} are each register and their position within the @samp{g} @var{packet} are
determined by the @value{GDBN} internal macros @var{REGISTER_RAW_SIZE} determined by the @value{GDBN} internal macros
and @var{REGISTER_NAME} macros. The specification of several standard @var{DEPRECATED_REGISTER_RAW_SIZE} and @var{REGISTER_NAME} macros. The
@code{g} packets is specified below. specification of several standard @code{g} packets is specified below.
@item E@var{NN} @item E@var{NN}
for an error. for an error.
@end table @end table
@ -19971,12 +19971,13 @@ conventions is used.
@var{AA} = two hex digit signal number; @var{n...} = register number @var{AA} = two hex digit signal number; @var{n...} = register number
(hex), @var{r...} = target byte ordered register contents, size defined (hex), @var{r...} = target byte ordered register contents, size defined
by @code{REGISTER_RAW_SIZE}; @var{n...} = @samp{thread}, @var{r...} = by @code{DEPRECATED_REGISTER_RAW_SIZE}; @var{n...} = @samp{thread},
thread process ID, this is a hex integer; @var{n...} = (@samp{watch} | @var{r...} = thread process ID, this is a hex integer; @var{n...} =
@samp{rwatch} | @samp{awatch}, @var{r...} = data address, this is a hex (@samp{watch} | @samp{rwatch} | @samp{awatch}, @var{r...} = data
integer; @var{n...} = other string not starting with valid hex digit. address, this is a hex integer; @var{n...} = other string not starting
@value{GDBN} should ignore this @var{n...}, @var{r...} pair and go on with valid hex digit. @value{GDBN} should ignore this @var{n...},
to the next. This way we can extend the protocol. @var{r...} pair and go on to the next. This way we can extend the
protocol.
@item W@var{AA} @item W@var{AA}

6
gdb/doc/gdbint.texinfo
View file

@ -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. unless this macro returns a non-zero value for that register.
@end deftypefn @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 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} of bytes the register will occupy in @code{registers}, or in a @value{GDBN}
remote protocol packet. remote protocol packet.
@ -3505,8 +3505,8 @@ Convert the raw contents of register @var{regnum} into a value of type
@var{type}. @var{type}.
@xref{Target Architecture Definition, , Using Different Register and Memory Data Representations}. @xref{Target Architecture Definition, , Using Different Register and Memory Data Representations}.
@item REGISTER_RAW_SIZE (@var{reg}) @item DEPRECATED_REGISTER_RAW_SIZE (@var{reg})
@findex REGISTER_RAW_SIZE @findex DEPRECATED_REGISTER_RAW_SIZE
Return the raw size of @var{reg}; defaults to the size of the register's Return the raw size of @var{reg}; defaults to the size of the register's
virtual type. virtual type.
@xref{Target Architecture Definition, , Raw and Virtual Register Representations}. @xref{Target Architecture Definition, , Raw and Virtual Register Representations}.

2
gdb/dve3900-rom.c
View file

@ -471,7 +471,7 @@ fetch_bitmapped_register (int regno, struct bit_field *bf)
/* supply register stores in target byte order, so swap here */ /* 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); supply_register (regno, regbuf);
} }

12
gdb/findvar.c
View file

@ -289,15 +289,15 @@ value_of_register (int regnum, struct frame_info *frame)
DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum, register_type (current_gdbarch, regnum), DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum, register_type (current_gdbarch, regnum),
raw_buffer, VALUE_CONTENTS_RAW (reg_val)); 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, memcpy (VALUE_CONTENTS_RAW (reg_val), raw_buffer,
REGISTER_RAW_SIZE (regnum)); DEPRECATED_REGISTER_RAW_SIZE (regnum));
else else
internal_error (__FILE__, __LINE__, internal_error (__FILE__, __LINE__,
"Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size", "Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size",
REGISTER_NAME (regnum), REGISTER_NAME (regnum),
regnum, regnum,
REGISTER_RAW_SIZE (regnum), DEPRECATED_REGISTER_RAW_SIZE (regnum),
DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum)); DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum));
VALUE_LVAL (reg_val) = lval; VALUE_LVAL (reg_val) = lval;
VALUE_ADDRESS (reg_val) = addr; 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. */ /* Copy all of the data out, whereever it may be. */
for (local_regnum = regnum, value_bytes_copied = 0; for (local_regnum = regnum, value_bytes_copied = 0;
value_bytes_copied < len; value_bytes_copied < len;
(value_bytes_copied += REGISTER_RAW_SIZE (local_regnum), (value_bytes_copied += DEPRECATED_REGISTER_RAW_SIZE (local_regnum),
++local_regnum)) ++local_regnum))
{ {
int realnum; 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 some fiddling with the last register copied here for little
endian machines. */ endian machines. */
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG 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. */ /* 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 else
VALUE_OFFSET (v) = 0; VALUE_OFFSET (v) = 0;
memcpy (VALUE_CONTENTS_RAW (v), value_bytes + VALUE_OFFSET (v), len); memcpy (VALUE_CONTENTS_RAW (v), value_bytes + VALUE_OFFSET (v), len);

17
gdb/frame.c
View file

@ -703,7 +703,8 @@ put_frame_register (struct frame_info *frame, int regnum, const void *buf)
/* frame_register_read () /* frame_register_read ()
Find and return the value of REGNUM for the specified stack frame. 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. */ 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) if (bufferp != NULL)
/* NOTE: cagney/2003-05-09: In-lined store_address with /* NOTE: cagney/2003-05-09: In-lined store_address with
it's body - store_unsigned_integer. */ 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]); deprecated_get_frame_saved_regs (frame)[regnum]);
} }
else else
@ -993,15 +994,15 @@ legacy_saved_regs_prev_register (struct frame_info *next_frame,
if (regs[regnum] == NULL) if (regs[regnum] == NULL)
{ {
regs[regnum] 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], 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 #else
/* Read the value in from memory. */ /* Read the value in from memory. */
read_memory (deprecated_get_frame_saved_regs (frame)[regnum], bufferp, read_memory (deprecated_get_frame_saved_regs (frame)[regnum], bufferp,
REGISTER_RAW_SIZE (regnum)); DEPRECATED_REGISTER_RAW_SIZE (regnum));
#endif #endif
} }
} }
@ -1109,7 +1110,7 @@ deprecated_generic_get_saved_register (char *raw_buffer, int *optimized,
/* NOTE: cagney/2003-05-09: In-line store_address /* NOTE: cagney/2003-05-09: In-line store_address
with it's body - store_unsigned_integer. */ with it's body - store_unsigned_integer. */
store_unsigned_integer (raw_buffer, store_unsigned_integer (raw_buffer,
REGISTER_RAW_SIZE (regnum), DEPRECATED_REGISTER_RAW_SIZE (regnum),
deprecated_get_frame_saved_regs (frame)[regnum]); deprecated_get_frame_saved_regs (frame)[regnum]);
} }
else else
@ -1118,7 +1119,7 @@ deprecated_generic_get_saved_register (char *raw_buffer, int *optimized,
*addrp = deprecated_get_frame_saved_regs (frame)[regnum]; *addrp = deprecated_get_frame_saved_regs (frame)[regnum];
if (raw_buffer) if (raw_buffer)
read_memory (deprecated_get_frame_saved_regs (frame)[regnum], raw_buffer, read_memory (deprecated_get_frame_saved_regs (frame)[regnum], raw_buffer,
REGISTER_RAW_SIZE (regnum)); DEPRECATED_REGISTER_RAW_SIZE (regnum));
} }
return; return;
} }

38
gdb/gdbarch.c
View file

@ -1524,6 +1524,25 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
(long) current_gdbarch->deprecated_register_convert_to_virtual (long) current_gdbarch->deprecated_register_convert_to_virtual
/*DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL ()*/); /*DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL ()*/);
#endif #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 #ifdef DEPRECATED_REGISTER_SIZE
fprintf_unfiltered (file, fprintf_unfiltered (file,
"gdbarch_dump: DEPRECATED_REGISTER_SIZE # %s\n", "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 (long) current_gdbarch->register_name
/*REGISTER_NAME ()*/); /*REGISTER_NAME ()*/);
#endif #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 #ifdef REGISTER_SIM_REGNO
fprintf_unfiltered (file, fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n", "gdbarch_dump: %s # %s\n",

24
gdb/gdbarch.h
View file

@ -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 DEPRECATED_REGISTER_RAW_SIZE can be deleted. See: maint print
registers. */ registers. */
#if defined (REGISTER_RAW_SIZE) #if defined (DEPRECATED_REGISTER_RAW_SIZE)
/* Legacy for systems yet to multi-arch REGISTER_RAW_SIZE */ /* Legacy for systems yet to multi-arch DEPRECATED_REGISTER_RAW_SIZE */
#if !defined (REGISTER_RAW_SIZE_P) #if !defined (DEPRECATED_REGISTER_RAW_SIZE_P)
#define REGISTER_RAW_SIZE_P() (1) #define DEPRECATED_REGISTER_RAW_SIZE_P() (1)
#endif #endif
#endif #endif
extern int gdbarch_deprecated_register_raw_size_p (struct gdbarch *gdbarch); extern int gdbarch_deprecated_register_raw_size_p (struct gdbarch *gdbarch);
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_RAW_SIZE_P) #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_REGISTER_RAW_SIZE_P)
#error "Non multi-arch definition of REGISTER_RAW_SIZE" #error "Non multi-arch definition of DEPRECATED_REGISTER_RAW_SIZE"
#endif #endif
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_RAW_SIZE_P) #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_REGISTER_RAW_SIZE_P)
#define REGISTER_RAW_SIZE_P() (gdbarch_deprecated_register_raw_size_p (current_gdbarch)) #define DEPRECATED_REGISTER_RAW_SIZE_P() (gdbarch_deprecated_register_raw_size_p (current_gdbarch))
#endif #endif
typedef int (gdbarch_deprecated_register_raw_size_ftype) (int reg_nr); 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 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); 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) #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_REGISTER_RAW_SIZE)
#error "Non multi-arch definition of REGISTER_RAW_SIZE" #error "Non multi-arch definition of DEPRECATED_REGISTER_RAW_SIZE"
#endif #endif
#if !defined (REGISTER_RAW_SIZE) #if !defined (DEPRECATED_REGISTER_RAW_SIZE)
#define REGISTER_RAW_SIZE(reg_nr) (gdbarch_deprecated_register_raw_size (current_gdbarch, reg_nr)) #define DEPRECATED_REGISTER_RAW_SIZE(reg_nr) (gdbarch_deprecated_register_raw_size (current_gdbarch, reg_nr))
#endif #endif
/* If all registers have identical raw and virtual sizes and those /* If all registers have identical raw and virtual sizes and those

2
gdb/gdbarch.sh
View file

@ -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, # sizes agree with the value computed from REGISTER_TYPE,
# DEPRECATED_REGISTER_RAW_SIZE can be deleted. See: maint print # DEPRECATED_REGISTER_RAW_SIZE can be deleted. See: maint print
# registers. # 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 # If all registers have identical raw and virtual sizes and those
# sizes agree with the value computed from REGISTER_TYPE, # sizes agree with the value computed from REGISTER_TYPE,
# DEPRECATED_REGISTER_VIRTUAL_SIZE can be deleted. See: maint print # DEPRECATED_REGISTER_VIRTUAL_SIZE can be deleted. See: maint print

11
gdb/hppa-tdep.c
View file

@ -2983,7 +2983,7 @@ pa_print_fp_reg (int i)
frame_register_read (deprecated_selected_frame, i, raw_buffer); frame_register_read (deprecated_selected_frame, i, raw_buffer);
/* Put it in the buffer. No conversions are ever necessary. */ /* 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); fputs_filtered (REGISTER_NAME (i), gdb_stdout);
print_spaces_filtered (8 - strlen (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); frame_register_read (deprecated_selected_frame, i + 1, raw_buffer);
/* Copy it into the appropriate part of the virtual buffer. */ /* Copy it into the appropriate part of the virtual buffer. */
memcpy (virtual_buffer + REGISTER_RAW_SIZE (i), raw_buffer, memcpy (virtual_buffer + DEPRECATED_REGISTER_RAW_SIZE (i), raw_buffer,
REGISTER_RAW_SIZE (i)); DEPRECATED_REGISTER_RAW_SIZE (i));
/* Dump it as a double. */ /* Dump it as a double. */
fputs_filtered (REGISTER_NAME (i), gdb_stdout); 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); frame_register_read (deprecated_selected_frame, i, raw_buffer);
/* Put it in the buffer. No conversions are ever necessary. */ /* 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) 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); frame_register_read (deprecated_selected_frame, i + 1, raw_buf);
/* Copy it into the appropriate part of the virtual buffer. */ /* 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, val_print (builtin_type_double, virtual_buffer, 0, 0, stream, 0,
1, 0, Val_pretty_default); 1, 0, Val_pretty_default);

4
gdb/hppab-nat.c
View file

@ -64,7 +64,7 @@ fetch_register (int regno)
offset = U_REGS_OFFSET; offset = U_REGS_OFFSET;
regaddr = register_addr (regno, 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; errno = 0;
*(int *) &buf[i] = ptrace (PT_RUREGS, PIDGET (inferior_ptid), *(int *) &buf[i] = ptrace (PT_RUREGS, PIDGET (inferior_ptid),
@ -130,7 +130,7 @@ store_inferior_registers (int regno)
} }
} }
else 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; errno = 0;
ptrace (PT_WUREGS, PIDGET (inferior_ptid), ptrace (PT_WUREGS, PIDGET (inferior_ptid),

21
gdb/hppah-nat.c
View file

@ -98,7 +98,7 @@ store_inferior_registers (int regno)
return; return;
offset = 0; offset = 0;
len = REGISTER_RAW_SIZE (regno); len = DEPRECATED_REGISTER_RAW_SIZE (regno);
/* Requests for register zero actually want the save_state's /* Requests for register zero actually want the save_state's
ss_flags member. As RM says: "Oh, what a hack!" */ ss_flags member. As RM says: "Oh, what a hack!" */
@ -109,10 +109,11 @@ store_inferior_registers (int regno)
len = sizeof (ss.ss_flags); len = sizeof (ss.ss_flags);
/* Note that ss_flags is always an int, no matter what /* Note that ss_flags is always an int, no matter what
REGISTER_RAW_SIZE(0) says. Assuming all HP-UX PA machines DEPRECATED_REGISTER_RAW_SIZE(0) says. Assuming all HP-UX
are big-endian, put it at the least significant end of the PA machines are big-endian, put it at the least
value, and zap the rest of the buffer. */ significant end of the value, and zap the rest of the
offset = REGISTER_RAW_SIZE (0) - len; buffer. */
offset = DEPRECATED_REGISTER_RAW_SIZE (0) - len;
} }
/* Floating-point registers come from the ss_fpblock area. */ /* Floating-point registers come from the ss_fpblock area. */
@ -215,7 +216,7 @@ fetch_register (int regno)
int i; int i;
offset = 0; offset = 0;
len = REGISTER_RAW_SIZE (regno); len = DEPRECATED_REGISTER_RAW_SIZE (regno);
/* Requests for register zero actually want the save_state's /* Requests for register zero actually want the save_state's
ss_flags member. As RM says: "Oh, what a hack!" */ ss_flags member. As RM says: "Oh, what a hack!" */
@ -226,10 +227,10 @@ fetch_register (int regno)
len = sizeof (ss.ss_flags); len = sizeof (ss.ss_flags);
/* Note that ss_flags is always an int, no matter what /* Note that ss_flags is always an int, no matter what
REGISTER_RAW_SIZE(0) says. Assuming all HP-UX PA machines DEPRECATED_REGISTER_RAW_SIZE(0) says. Assuming all HP-UX PA
are big-endian, put it at the least significant end of the machines are big-endian, put it at the least significant end
value, and zap the rest of the buffer. */ of the value, and zap the rest of the buffer. */
offset = REGISTER_RAW_SIZE (0) - len; offset = DEPRECATED_REGISTER_RAW_SIZE (0) - len;
memset (buf, 0, sizeof (buf)); memset (buf, 0, sizeof (buf));
} }

4
gdb/hppam3-nat.c
View file

@ -116,13 +116,13 @@ store_inferior_registers (int regno)
if (regno > 0 && regno < NUM_REGS) if (regno > 0 && regno < NUM_REGS)
{ {
memcpy (&state[regno], &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)], memcpy (&state[regno], &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)],
REGISTER_RAW_SIZE (regno)); DEPRECATED_REGISTER_RAW_SIZE (regno));
} }
else else
{ {
for (index = 0; index < NUM_REGS; index++) for (index = 0; index < NUM_REGS; index++)
memcpy (&state[index], &deprecated_registers[DEPRECATED_REGISTER_BYTE (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)]; */ /* state[index] = deprecated_registers[DEPRECATED_REGISTER_BYTE (index)]; */
} }

14
gdb/hpux-thread.c
View file

@ -291,13 +291,13 @@ hpux_thread_fetch_registers (int regno)
if (regno == FLAGS_REGNUM) if (regno == FLAGS_REGNUM)
/* Flags must be 0 to avoid bogus value for SS_INSYSCALL */ /* 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) else if (regno == SP_REGNUM)
store_unsigned_integer (buf, sizeof sp, sp); store_unsigned_integer (buf, sizeof sp, sp);
else if (regno == PC_REGNUM) 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 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); supply_register (regno, buf);
} }
@ -357,19 +357,19 @@ hpux_thread_store_registers (int regno)
{ {
write_memory ((CORE_ADDR) & tcb_ptr->static_ctx.sp, write_memory ((CORE_ADDR) & tcb_ptr->static_ctx.sp,
&deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)], &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)],
REGISTER_RAW_SIZE (regno)); DEPRECATED_REGISTER_RAW_SIZE (regno));
tcb_ptr->static_ctx.sp = (cma__t_hppa_regs *) tcb_ptr->static_ctx.sp = (cma__t_hppa_regs *)
(extract_unsigned_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)], (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) else if (regno == PC_REGNUM)
write_memory (sp - 20, write_memory (sp - 20,
&deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)], &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)],
REGISTER_RAW_SIZE (regno)); DEPRECATED_REGISTER_RAW_SIZE (regno));
else else
write_memory (sp + regmap[regno], write_memory (sp + regmap[regno],
&deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)], &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)],
REGISTER_RAW_SIZE (regno)); DEPRECATED_REGISTER_RAW_SIZE (regno));
} }
} }

4
gdb/i386gnu-nat.c
View file

@ -242,7 +242,7 @@ gnu_store_registers (int regno)
if ((thread->fetched_regs & (1 << check_regno)) if ((thread->fetched_regs & (1 << check_regno))
&& memcpy (REG_ADDR (&old_state, check_regno), && memcpy (REG_ADDR (&old_state, check_regno),
REG_ADDR (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! */ /* Register CHECK_REGNO has changed! Ack! */
{ {
warning ("Register %s changed after the thread was aborted", warning ("Register %s changed after the thread was aborted",
@ -257,7 +257,7 @@ gnu_store_registers (int regno)
#define fill(state, regno) \ #define fill(state, regno) \
memcpy (REG_ADDR(state, regno), &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)], \ memcpy (REG_ADDR(state, regno), &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)], \
REGISTER_RAW_SIZE (regno)) DEPRECATED_REGISTER_RAW_SIZE (regno))
if (regno == -1) if (regno == -1)
{ {

8
gdb/ia64-aix-nat.c
View file

@ -87,7 +87,7 @@ fill_gregset (prgregset_t *gregsetp, int regno)
#define COPY_REG(_fld_,_regi_) \ #define COPY_REG(_fld_,_regi_) \
if ((regno == -1) || regno == _regi_) \ if ((regno == -1) || regno == _regi_) \
memcpy (&(gregsetp->_fld_), &deprecated_registers[DEPRECATED_REGISTER_BYTE (_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++) for (regi = IA64_GR0_REGNUM; regi <= IA64_GR31_REGNUM; regi++)
{ {
@ -110,10 +110,10 @@ fill_gregset (prgregset_t *gregsetp, int regno)
{ {
memcpy (&(gregsetp->__bspstore), memcpy (&(gregsetp->__bspstore),
&deprecated_registers[DEPRECATED_REGISTER_BYTE (IA64_BSP_REGNUM)], &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)], memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (IA64_BSPSTORE_REGNUM)],
&deprecated_registers[DEPRECATED_REGISTER_BYTE (IA64_BSP_REGNUM)], &deprecated_registers[DEPRECATED_REGISTER_BYTE (IA64_BSP_REGNUM)],
REGISTER_RAW_SIZE (IA64_BSP_REGNUM)); DEPRECATED_REGISTER_RAW_SIZE (IA64_BSP_REGNUM));
} }
#if 0 #if 0
@ -156,7 +156,7 @@ fill_fpregset (prfpregset_t *fpregsetp, int regno)
{ {
from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)]; from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)];
to = (char *) &(fpregsetp->__fpr[regi - IA64_FR0_REGNUM]); to = (char *) &(fpregsetp->__fpr[regi - IA64_FR0_REGNUM]);
memcpy (to, from, REGISTER_RAW_SIZE (regi)); memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regi));
} }
} }
} }

4
gdb/ia64-linux-nat.c
View file

@ -403,7 +403,7 @@ fill_gregset (gregset_t *gregsetp, int regno)
#define COPY_REG(_idx_,_regi_) \ #define COPY_REG(_idx_,_regi_) \
if ((regno == -1) || regno == _regi_) \ if ((regno == -1) || regno == _regi_) \
memcpy (regp + _idx_, &deprecated_registers[DEPRECATED_REGISTER_BYTE (_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++) 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)]; from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)];
to = (char *) &((*fpregsetp)[regi - IA64_FR0_REGNUM]); to = (char *) &((*fpregsetp)[regi - IA64_FR0_REGNUM]);
memcpy (to, from, REGISTER_RAW_SIZE (regi)); memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regi));
} }
} }
} }

50
gdb/ia64-tdep.c
View file

@ -343,7 +343,7 @@ read_sigcontext_register (struct frame_info *frame, int regnum)
regaddr = SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), regnum); regaddr = SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), regnum);
if (regaddr) if (regaddr)
return read_memory_integer (regaddr, REGISTER_RAW_SIZE (regnum)); return read_memory_integer (regaddr, DEPRECATED_REGISTER_RAW_SIZE (regnum));
else else
internal_error (__FILE__, __LINE__, internal_error (__FILE__, __LINE__,
"read_sigcontext_register: Register %d not in struct sigcontext", regnum); "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)); ULONGEST reg_addr = rse_address_add (bsp, (regnum - V32_REGNUM));
reg = read_memory_integer ((CORE_ADDR)reg_addr, 8); 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 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) 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; ULONGEST unat;
regcache_cooked_read_unsigned (regcache, IA64_UNAT_REGNUM, &unat); regcache_cooked_read_unsigned (regcache, IA64_UNAT_REGNUM, &unat);
unatN_val = (unat & (1LL << (regnum - IA64_NAT0_REGNUM))) != 0; 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) 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; 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) 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 /* The bsp points at the end of the register frame so we
subtract the size of frame from it to get beginning of frame. */ subtract the size of frame from it to get beginning of frame. */
vbsp = rse_address_add (bsp, -(cfm & 0x7f)); 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) 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; + ((regnum - VP16_REGNUM) + rrb_pr) % 48;
} }
prN_val = (pr & (1LL << (regnum - VP0_REGNUM))) != 0; 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 else
memset (buf, 0, REGISTER_RAW_SIZE (regnum)); memset (buf, 0, DEPRECATED_REGISTER_RAW_SIZE (regnum));
} }
static void static void
@ -829,7 +829,7 @@ ia64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
{ {
ULONGEST unatN_val, unat, unatN_mask; ULONGEST unatN_val, unat, unatN_mask;
regcache_cooked_read_unsigned (regcache, IA64_UNAT_REGNUM, &unat); 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)); unatN_mask = (1LL << (regnum - IA64_NAT0_REGNUM));
if (unatN_val == 0) if (unatN_val == 0)
unat &= ~unatN_mask; unat &= ~unatN_mask;
@ -853,7 +853,7 @@ ia64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
if ((cfm & 0x7f) > regnum - V32_REGNUM) if ((cfm & 0x7f) > regnum - V32_REGNUM)
gr_addr = rse_address_add (bsp, (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)) 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; nat_collection |= natN_mask;
else else
nat_collection &= ~natN_mask; 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); 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
+ ((regnum - VP16_REGNUM) + rrb_pr) % 48; + ((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)); prN_mask = (1LL << (regnum - VP0_REGNUM));
if (prN_val == 0) if (prN_val == 0)
pr &= ~prN_mask; pr &= ~prN_mask;
@ -1593,12 +1593,12 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
if (!valuep) if (!valuep)
valuep = dummy_valp; valuep = dummy_valp;
memset (valuep, 0, REGISTER_RAW_SIZE (regnum)); memset (valuep, 0, DEPRECATED_REGISTER_RAW_SIZE (regnum));
if (regnum == SP_REGNUM) if (regnum == SP_REGNUM)
{ {
/* Handle SP values for all frames but the topmost. */ /* 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); cache->base);
} }
else if (regnum == IA64_BSP_REGNUM) 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)); bsp = rse_address_add (cache->bsp, -(cache->sof));
prev_bsp = rse_address_add (bsp, (prev_cfm & 0x7f) - ((prev_cfm >> 7) & 0x7f)); 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); prev_bsp);
} }
else if (regnum == IA64_CFM_REGNUM) 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]; addr = cache->saved_regs[IA64_CFM_REGNUM];
if (addr != 0) 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) 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 above. If the function lacks one of these frame pointers, we can
still provide a value since we know the size of the frame. */ still provide a value since we know the size of the frame. */
CORE_ADDR vfp = cache->base; 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) 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, prN_val = extract_bit_field ((unsigned char *) pr_valuep,
regnum - VP0_REGNUM, 1); 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) 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); &unat_optim, &unat_lval, &unat_addr, &unat_realnum, unat_valuep);
unatN_val = extract_bit_field ((unsigned char *) unat_valuep, unatN_val = extract_bit_field ((unsigned char *) unat_valuep,
regnum - IA64_NAT0_REGNUM, 1); regnum - IA64_NAT0_REGNUM, 1);
store_unsigned_integer (valuep, REGISTER_RAW_SIZE (regnum), store_unsigned_integer (valuep, DEPRECATED_REGISTER_RAW_SIZE (regnum),
unatN_val); unatN_val);
} }
else if (IA64_NAT32_REGNUM <= regnum && regnum <= IA64_NAT127_REGNUM) 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; 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) 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]; CORE_ADDR addr = cache->saved_regs[IA64_VRAP_REGNUM];
if (addr != 0) 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); 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]; CORE_ADDR addr = cache->saved_regs[IA64_VRAP_REGNUM];
if (addr != 0) 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); 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; *lvalp = lval_memory;
*addrp = addr; *addrp = addr;
read_memory (addr, valuep, REGISTER_RAW_SIZE (regnum)); read_memory (addr, valuep, DEPRECATED_REGISTER_RAW_SIZE (regnum));
} }
else if (cache->frameless) 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)); addr = rse_address_add (prev_bof, (regnum - IA64_GR32_REGNUM));
*lvalp = lval_memory; *lvalp = lval_memory;
*addrp = addr; *addrp = addr;
read_memory (addr, valuep, REGISTER_RAW_SIZE (regnum)); read_memory (addr, valuep, DEPRECATED_REGISTER_RAW_SIZE (regnum));
} }
} }
else else
@ -1833,7 +1833,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
{ {
*lvalp = lval_memory; *lvalp = lval_memory;
*addrp = addr; *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. */ /* Otherwise, punt and get the current value of the register. */
else else

4
gdb/infcmd.c
View file

@ -1592,13 +1592,13 @@ default_print_registers_info (struct gdbarch *gdbarch,
file, 0, 1, 0, Val_pretty_default); file, 0, 1, 0, Val_pretty_default);
fprintf_filtered (file, "\t(raw 0x"); 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; int idx;
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
idx = j; idx = j;
else 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, "%02x", (unsigned char) raw_buffer[idx]);
} }
fprintf_filtered (file, ")"); fprintf_filtered (file, ")");

6
gdb/infptrace.c
View file

@ -366,7 +366,7 @@ fetch_register (int regno)
if (CANNOT_FETCH_REGISTER (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); supply_register (regno, buf);
return; return;
} }
@ -378,7 +378,7 @@ fetch_register (int regno)
offset = U_REGS_OFFSET; offset = U_REGS_OFFSET;
regaddr = register_addr (regno, 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; errno = 0;
*(PTRACE_XFER_TYPE *) & buf[i] = ptrace (PT_READ_U, tid, *(PTRACE_XFER_TYPE *) & buf[i] = ptrace (PT_READ_U, tid,
@ -445,7 +445,7 @@ store_register (int regno)
regcache_collect (regno, buf); regcache_collect (regno, buf);
/* Store the local buffer into the inferior a chunk at the time. */ /* 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; errno = 0;
ptrace (PT_WRITE_U, tid, (PTRACE_ARG3_TYPE) regaddr, ptrace (PT_WRITE_U, tid, (PTRACE_ARG3_TYPE) regaddr,

2
gdb/infrun.c
View file

@ -3622,7 +3622,7 @@ void
write_inferior_status_register (struct inferior_status *inf_status, int regno, write_inferior_status_register (struct inferior_status *inf_status, int regno,
LONGEST val) LONGEST val)
{ {
int size = REGISTER_RAW_SIZE (regno); int size = DEPRECATED_REGISTER_RAW_SIZE (regno);
void *buf = alloca (size); void *buf = alloca (size);
store_signed_integer (buf, size, val); store_signed_integer (buf, size, val);
regcache_raw_write (inf_status->registers, regno, buf); regcache_raw_write (inf_status->registers, regno, buf);

14
gdb/irix5-nat.c
View file

@ -84,27 +84,27 @@ fill_gregset (gregset_t *gregsetp, int regno)
if ((regno == -1) || (regno == regi)) if ((regno == -1) || (regno == regi))
*(regp + regi) = *(regp + regi) =
extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (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)) if ((regno == -1) || (regno == PC_REGNUM))
*(regp + CTX_EPC) = *(regp + CTX_EPC) =
extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)], 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)) if ((regno == -1) || (regno == CAUSE_REGNUM))
*(regp + CTX_CAUSE) = *(regp + CTX_CAUSE) =
extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (CAUSE_REGNUM)], 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)) if ((regno == -1) || (regno == HI_REGNUM))
*(regp + CTX_MDHI) = *(regp + CTX_MDHI) =
extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (HI_REGNUM)], 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)) if ((regno == -1) || (regno == LO_REGNUM))
*(regp + CTX_MDLO) = *(regp + CTX_MDLO) =
extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (LO_REGNUM)], 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)]; from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)];
to = (char *) &(fpregsetp->fp_r.fp_regs[regi - FP0_REGNUM]); 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++; *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? /* copying 4 bytes from eight bytes?
I don't see how this can be right... */ I don't see how this can be right... */

28
gdb/lynx-nat.c
View file

@ -293,12 +293,12 @@ fetch_inferior_registers (int regno)
if (errno) if (errno)
perror_with_name ("ptrace(PTRACE_GETREGS)"); 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 (G0_REGNUM, buf);
supply_register (TBR_REGNUM, (char *) &ec.tbr); supply_register (TBR_REGNUM, (char *) &ec.tbr);
memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (G1_REGNUM)], &ec.g1, 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++) for (i = G1_REGNUM; i <= G1_REGNUM + 3; i++)
deprecated_register_valid[i] = 1; deprecated_register_valid[i] = 1;
@ -309,7 +309,7 @@ fetch_inferior_registers (int regno)
supply_register (WIM_REGNUM, (char *) &ec.wim); supply_register (WIM_REGNUM, (char *) &ec.wim);
memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (O0_REGNUM)], ec.o, 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++) for (i = O0_REGNUM; i <= O0_REGNUM + 7; i++)
deprecated_register_valid[i] = 1; deprecated_register_valid[i] = 1;
} }
@ -323,13 +323,13 @@ fetch_inferior_registers (int regno)
target_read_memory (sp + FRAME_SAVED_I0, target_read_memory (sp + FRAME_SAVED_I0,
&deprecated_registers[DEPRECATED_REGISTER_BYTE (I0_REGNUM)], &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++) for (i = I0_REGNUM; i <= I7_REGNUM; i++)
deprecated_register_valid[i] = 1; deprecated_register_valid[i] = 1;
target_read_memory (sp + FRAME_SAVED_L0, target_read_memory (sp + FRAME_SAVED_L0,
&deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)], &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++) for (i = L0_REGNUM; i <= L0_REGNUM + 7; i++)
deprecated_register_valid[i] = 1; deprecated_register_valid[i] = 1;
} }
@ -347,7 +347,7 @@ fetch_inferior_registers (int regno)
perror_with_name ("ptrace(PTRACE_GETFPREGS)"); perror_with_name ("ptrace(PTRACE_GETFPREGS)");
memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)], fc.f.fregs, 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++) for (i = FP0_REGNUM; i <= FP0_REGNUM + 31; i++)
deprecated_register_valid[i] = 1; deprecated_register_valid[i] = 1;
@ -385,7 +385,7 @@ store_inferior_registers (int regno)
ec.tbr = read_register (TBR_REGNUM); ec.tbr = read_register (TBR_REGNUM);
memcpy (&ec.g1, &deprecated_registers[DEPRECATED_REGISTER_BYTE (G1_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.psr = read_register (PS_REGNUM);
ec.y = read_register (Y_REGNUM); ec.y = read_register (Y_REGNUM);
@ -394,7 +394,7 @@ store_inferior_registers (int regno)
ec.wim = read_register (WIM_REGNUM); ec.wim = read_register (WIM_REGNUM);
memcpy (ec.o, &deprecated_registers[DEPRECATED_REGISTER_BYTE (O0_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; errno = 0;
retval = ptrace (PTRACE_SETREGS, PIDGET (inferior_ptid), retval = ptrace (PTRACE_SETREGS, PIDGET (inferior_ptid),
@ -416,11 +416,11 @@ store_inferior_registers (int regno)
internal_error (__FILE__, __LINE__, "failed internal consistency check"); internal_error (__FILE__, __LINE__, "failed internal consistency check");
target_write_memory (sp + FRAME_SAVED_I0, target_write_memory (sp + FRAME_SAVED_I0,
&deprecated_registers[DEPRECATED_REGISTER_BYTE (I0_REGNUM)], &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, target_write_memory (sp + FRAME_SAVED_L0,
&deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)], &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) else if (regno >= L0_REGNUM && regno <= I7_REGNUM)
{ {
@ -434,7 +434,7 @@ store_inferior_registers (int regno)
+ FRAME_SAVED_I0; + FRAME_SAVED_I0;
target_write_memory (sp + regoffset, target_write_memory (sp + regoffset,
&deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)], &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)"); perror_with_name ("ptrace(PTRACE_GETFPREGS)");
memcpy (fc.f.fregs, &deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)], 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); fc.fsr = read_register (FPS_REGNUM);
@ -521,7 +521,7 @@ fetch_inferior_registers (int regno)
ptrace_fun = regno == SP_REGNUM ? PTRACE_PEEKUSP : PTRACE_PEEKTHREAD; ptrace_fun = regno == SP_REGNUM ? PTRACE_PEEKUSP : PTRACE_PEEKTHREAD;
#endif #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; unsigned int reg;
@ -570,7 +570,7 @@ store_inferior_registers (int regno)
ptrace_fun = regno == SP_REGNUM ? PTRACE_POKEUSP : PTRACE_POKEUSER; ptrace_fun = regno == SP_REGNUM ? PTRACE_POKEUSP : PTRACE_POKEUSER;
#endif #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; unsigned int reg;

7
gdb/mi/ChangeLog
View file

@ -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> 2003-09-30 Andrew Cagney <cagney@redhat.com>
* mi-main.c: Rename REGISTER_VIRTUAL_SIZE to * mi-main.c: Rename REGISTER_VIRTUAL_SIZE to
@ -5,7 +10,7 @@
2003-09-17 Andrew Cagney <cagney@redhat.com> 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> 2003-09-10 Elena Zannoni <ezannoni@redhat.com>

10
gdb/mi/mi-main.c
View file

@ -406,13 +406,13 @@ register_changed_p (int regnum)
return -1; return -1;
if (memcmp (&old_regs[DEPRECATED_REGISTER_BYTE (regnum)], raw_buffer, if (memcmp (&old_regs[DEPRECATED_REGISTER_BYTE (regnum)], raw_buffer,
REGISTER_RAW_SIZE (regnum)) == 0) DEPRECATED_REGISTER_RAW_SIZE (regnum)) == 0)
return 0; return 0;
/* Found a changed register. Return 1. */ /* Found a changed register. Return 1. */
memcpy (&old_regs[DEPRECATED_REGISTER_BYTE (regnum)], raw_buffer, memcpy (&old_regs[DEPRECATED_REGISTER_BYTE (regnum)], raw_buffer,
REGISTER_RAW_SIZE (regnum)); DEPRECATED_REGISTER_RAW_SIZE (regnum));
return 1; return 1;
} }
@ -553,10 +553,10 @@ get_register (int regnum, int format)
strcpy (buf, "0x"); strcpy (buf, "0x");
ptr = buf + 2; 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 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]); sprintf (ptr, "%02x", (unsigned char) raw_buffer[idx]);
ptr += 2; ptr += 2;
} }
@ -642,7 +642,7 @@ mi_cmd_data_write_register_values (char *command, char **argv, int argc)
old_chain = make_cleanup (xfree, buffer); old_chain = make_cleanup (xfree, buffer);
store_signed_integer (buffer, DEPRECATED_REGISTER_SIZE, value); store_signed_integer (buffer, DEPRECATED_REGISTER_SIZE, value);
/* Write it down */ /* 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. */ /* Free the buffer. */
do_cleanups (old_chain); do_cleanups (old_chain);
} }

10
gdb/mips-linux-tdep.c
View file

@ -92,7 +92,7 @@ static void
supply_32bit_reg (int regnum, const void *addr) supply_32bit_reg (int regnum, const void *addr)
{ {
char buf[MAX_REGISTER_SIZE]; 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)); extract_signed_integer (addr, 4));
supply_register (regnum, buf); supply_register (regnum, buf);
} }
@ -218,13 +218,13 @@ fill_fpregset (elf_fpregset_t *fpregsetp, int regno)
{ {
from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)]; from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)];
to = (char *) (*fpregsetp + regno - FP0_REGNUM); 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) else if (regno == FCRCS_REGNUM)
{ {
from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)]; from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)];
to = (char *) (*fpregsetp + 32); to = (char *) (*fpregsetp + 32);
memcpy (to, from, REGISTER_RAW_SIZE (regno)); memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regno));
} }
else if (regno == -1) 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)]; from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)];
to = (char *) (*fpregsetp + regno - FP0_REGNUM); 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) else if (regno == FCRCS_REGNUM)
{ {
from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)]; from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)];
to = (char *) (*fpregsetp + 32); to = (char *) (*fpregsetp + 32);
memcpy (to, from, REGISTER_RAW_SIZE (regno)); memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regno));
} }
else if (regno == -1) else if (regno == -1)
{ {

2
gdb/mips-nat.c
View file

@ -83,7 +83,7 @@ fetch_inferior_registers (int regno)
for (regno = 1; regno < NUM_REGS; regno++) for (regno = 1; regno < NUM_REGS; regno++)
{ {
regaddr = register_ptrace_addr (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), *(int *) &buf[i] = ptrace (PT_READ_U, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) regaddr, 0); (PTRACE_ARG3_TYPE) regaddr, 0);

60
gdb/mips-tdep.c
View file

@ -181,9 +181,9 @@ unmake_mips16_addr (CORE_ADDR addr)
static LONGEST static LONGEST
read_signed_register (int regnum) 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); 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 static LONGEST
@ -279,7 +279,7 @@ mips_xfer_register (struct regcache *regcache, int reg_num, int length,
switch (endian) switch (endian)
{ {
case BFD_ENDIAN_BIG: case BFD_ENDIAN_BIG:
reg_offset = REGISTER_RAW_SIZE (reg_num) - length; reg_offset = DEPRECATED_REGISTER_RAW_SIZE (reg_num) - length;
break; break;
case BFD_ENDIAN_LITTLE: case BFD_ENDIAN_LITTLE:
reg_offset = 0; 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 /* MIPS1 and MIPS2 have only 32 bit FPRs, and the FR bit is not
meaningful. */ meaningful. */
if (REGISTER_RAW_SIZE (FP0_REGNUM) == 4) if (DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM) == 4)
return 0; return 0;
#if 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 NOTE: cagney/2003-06-15: This is so bogus. The register's
raw size is changing according to the ABI raw size is changing according to the ABI
(FP_REGISTER_DOUBLE). Also, GDB's protocol is defined by a (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) if (mips64_transfers_32bit_regs_p)
return DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum); return DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum);
else if (regnum >= FP0_REGNUM && regnum < FP0_REGNUM + 32 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) if (mips64_transfers_32bit_regs_p)
return 0; return 0;
else 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 static void
@ -726,7 +726,7 @@ mips_register_convert_to_virtual (int n, struct type *virtual_type,
{ {
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
memcpy (virt_buf, 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)); TYPE_LENGTH (virtual_type));
else else
memcpy (virt_buf, memcpy (virt_buf,
@ -738,9 +738,9 @@ static void
mips_register_convert_to_raw (struct type *virtual_type, int n, mips_register_convert_to_raw (struct type *virtual_type, int n,
const char *virt_buf, char *raw_buf) 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) 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, virt_buf,
TYPE_LENGTH (virtual_type)); TYPE_LENGTH (virtual_type));
else else
@ -753,7 +753,7 @@ static int
mips_convert_register_p (int regnum, struct type *type) mips_convert_register_p (int regnum, struct type *type)
{ {
return (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG 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 && (regnum) >= FP0_REGNUM && (regnum) < FP0_REGNUM + 32
&& TYPE_CODE(type) == TYPE_CODE_FLT && TYPE_CODE(type) == TYPE_CODE_FLT
&& TYPE_LENGTH(type) == 8); && TYPE_LENGTH(type) == 8);
@ -4065,7 +4065,7 @@ static void
mips_read_fp_register_single (struct frame_info *frame, int regno, mips_read_fp_register_single (struct frame_info *frame, int regno,
char *rare_buffer) char *rare_buffer)
{ {
int raw_size = REGISTER_RAW_SIZE (regno); int raw_size = DEPRECATED_REGISTER_RAW_SIZE (regno);
char *raw_buffer = alloca (raw_size); char *raw_buffer = alloca (raw_size);
if (!frame_register_read (frame, regno, raw_buffer)) 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, mips_read_fp_register_double (struct frame_info *frame, int regno,
char *rare_buffer) 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 ()) 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 */ double doub, flt1, flt2; /* doubles extracted from raw hex data */
int inv1, inv2, namelen; 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:", REGISTER_NAME (regnum));
fprintf_filtered (file, "%*s", 4 - (int) strlen (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 /* 4-byte registers: Print hex and floating. Also print even
numbered registers as doubles. */ numbered registers as doubles. */
@ -4229,7 +4229,7 @@ mips_print_register (struct ui_file *file, struct frame_info *frame,
fprintf_filtered (file, ": "); fprintf_filtered (file, ": ");
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) 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 else
offset = 0; offset = 0;
@ -4301,8 +4301,8 @@ print_gp_register_row (struct ui_file *file, struct frame_info *frame,
printf_filtered (" "); printf_filtered (" ");
/* Now print the register value in hex, endian order. */ /* Now print the register value in hex, endian order. */
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
for (byte = REGISTER_RAW_SIZE (regnum) - DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum); for (byte = DEPRECATED_REGISTER_RAW_SIZE (regnum) - DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum);
byte < REGISTER_RAW_SIZE (regnum); byte < DEPRECATED_REGISTER_RAW_SIZE (regnum);
byte++) byte++)
fprintf_filtered (file, "%02x", (unsigned char) raw_buffer[byte]); fprintf_filtered (file, "%02x", (unsigned char) raw_buffer[byte]);
else else
@ -4641,7 +4641,7 @@ return_value_location (struct type *valtype,
lo->buf_offset = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? 4 : 0; lo->buf_offset = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? 4 : 0;
hi->buf_offset = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? 0 : 4; hi->buf_offset = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? 0 : 4;
lo->reg_offset = ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG lo->reg_offset = ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
&& REGISTER_RAW_SIZE (FP0_REGNUM) == 8) && DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM) == 8)
? 4 : 0); ? 4 : 0);
hi->reg_offset = lo->reg_offset; hi->reg_offset = lo->reg_offset;
lo->reg = FP0_REGNUM + 0; 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 /* The floating point value fits in a single floating-point
register. */ register. */
lo->reg_offset = ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG lo->reg_offset = ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
&& REGISTER_RAW_SIZE (FP0_REGNUM) == 8 && DEPRECATED_REGISTER_RAW_SIZE (FP0_REGNUM) == 8
&& len == 4) && len == 4)
? 4 : 0); ? 4 : 0);
lo->reg = FP0_REGNUM; lo->reg = FP0_REGNUM;
@ -4710,7 +4710,7 @@ return_value_location (struct type *valtype,
} }
} }
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
&& REGISTER_RAW_SIZE (regnum) == 8 && DEPRECATED_REGISTER_RAW_SIZE (regnum) == 8
&& MIPS_SAVED_REGSIZE == 4) && MIPS_SAVED_REGSIZE == 4)
{ {
/* Account for the fact that only the least-signficant part /* 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)); memset (raw_buffer, 0, sizeof (raw_buffer));
memcpy (raw_buffer + lo.reg_offset, valbuf + lo.buf_offset, lo.len); memcpy (raw_buffer + lo.reg_offset, valbuf + lo.buf_offset, lo.len);
deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (lo.reg), raw_buffer, 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) if (hi.len > 0)
{ {
memset (raw_buffer, 0, sizeof (raw_buffer)); memset (raw_buffer, 0, sizeof (raw_buffer));
memcpy (raw_buffer + hi.reg_offset, valbuf + hi.buf_offset, hi.len); memcpy (raw_buffer + hi.reg_offset, valbuf + hi.buf_offset, hi.len);
deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (hi.reg), raw_buffer, 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)); memset (raw_buffer, 0, sizeof (raw_buffer));
memcpy (raw_buffer + lo.reg_offset, valbuf + lo.buf_offset, lo.len); memcpy (raw_buffer + lo.reg_offset, valbuf + lo.buf_offset, lo.len);
deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (lo.reg), raw_buffer, 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) if (hi.len > 0)
{ {
memset (raw_buffer, 0, sizeof (raw_buffer)); memset (raw_buffer, 0, sizeof (raw_buffer));
memcpy (raw_buffer + hi.reg_offset, valbuf + hi.buf_offset, hi.len); memcpy (raw_buffer + hi.reg_offset, valbuf + hi.buf_offset, hi.len);
deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (hi.reg), raw_buffer, 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; int regnum;
for (offset = 0, regnum = V0_REGNUM; for (offset = 0, regnum = V0_REGNUM;
offset < TYPE_LENGTH (type); 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)) if (offset + xfer > TYPE_LENGTH (type))
xfer = TYPE_LENGTH (type) - offset; xfer = TYPE_LENGTH (type) - offset;
if (mips_debug) if (mips_debug)
@ -5013,9 +5013,9 @@ mips_n32n64_xfer_return_value (struct type *type,
int regnum; int regnum;
for (offset = 0, regnum = V0_REGNUM; for (offset = 0, regnum = V0_REGNUM;
offset < TYPE_LENGTH (type); 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)) if (offset + xfer > TYPE_LENGTH (type))
xfer = TYPE_LENGTH (type) - offset; xfer = TYPE_LENGTH (type) - offset;
if (mips_debug) if (mips_debug)
@ -5033,9 +5033,9 @@ mips_n32n64_xfer_return_value (struct type *type,
int regnum; int regnum;
for (offset = 0, regnum = V0_REGNUM; for (offset = 0, regnum = V0_REGNUM;
offset < TYPE_LENGTH (type); 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; int pos = 0;
if (offset + xfer > TYPE_LENGTH (type)) if (offset + xfer > TYPE_LENGTH (type))
xfer = TYPE_LENGTH (type) - offset; xfer = TYPE_LENGTH (type) - offset;

2
gdb/mipsv4-nat.c
View file

@ -127,7 +127,7 @@ fill_fpregset (fpregset_t *fpregsetp, int regno)
{ {
from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)]; from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)];
to = (char *) &(fpregsetp->fp_r.fp_regs[regi - FP0_REGNUM]); 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));
} }
} }

8
gdb/mn10300-tdep.c
View file

@ -134,7 +134,7 @@ static CORE_ADDR
mn10300_extract_struct_value_address (char *regbuf) mn10300_extract_struct_value_address (char *regbuf)
{ {
return extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (4), return extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (4),
REGISTER_RAW_SIZE (4)); DEPRECATED_REGISTER_RAW_SIZE (4));
} }
static void static void
@ -749,7 +749,7 @@ mn10300_pop_frame_regular (struct frame_info *frame)
ULONGEST value; ULONGEST value;
value = read_memory_unsigned_integer (deprecated_get_frame_saved_regs (frame)[regnum], 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); write_register (regnum, value);
} }
@ -1039,8 +1039,8 @@ mn10300_print_register (const char *name, int regnum, int reg_width)
int byte; int byte;
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
{ {
for (byte = REGISTER_RAW_SIZE (regnum) - DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum); for (byte = DEPRECATED_REGISTER_RAW_SIZE (regnum) - DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum);
byte < REGISTER_RAW_SIZE (regnum); byte < DEPRECATED_REGISTER_RAW_SIZE (regnum);
byte++) byte++)
printf_filtered ("%02x", (unsigned char) raw_buffer[byte]); printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
} }

6
gdb/monitor.c
View file

@ -929,7 +929,7 @@ monitor_supply_register (int regno, char *valstr)
/* supply register stores in target byte order, so swap here */ /* 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); supply_register (regno, regbuf);
@ -1235,7 +1235,7 @@ monitor_fetch_register (int regno)
spaces, but stop reading if something else is seen. Some monitors spaces, but stop reading if something else is seen. Some monitors
like to drop leading zeros. */ 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; int c;
c = readchar (timeout); c = readchar (timeout);
@ -1352,7 +1352,7 @@ monitor_store_register (int regno)
val = read_register (regno); val = read_register (regno);
monitor_debug ("MON storeg %d %s\n", 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 */ /* send the register deposit command */

2
gdb/ns32k-tdep.c
View file

@ -498,7 +498,7 @@ ns32k_store_return_value (struct type *valtype, char *valbuf)
static CORE_ADDR static CORE_ADDR
ns32k_extract_struct_value_address (char *regbuf) 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 void

22
gdb/ppc-linux-nat.c
View file

@ -178,7 +178,7 @@ fetch_altivec_register (int tid, int regno)
int offset = 0; int offset = 0;
gdb_vrregset_t regs; gdb_vrregset_t regs;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); 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, &regs); ret = ptrace (PTRACE_GETVRREGS, tid, 0, &regs);
if (ret < 0) 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 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. */ there is no need to define an offset for it. */
if (regno == (tdep->ppc_vrsave_regnum - 1)) 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, supply_register (regno,
regs + (regno - tdep->ppc_vr0_regnum) * vrregsize + offset); regs + (regno - tdep->ppc_vr0_regnum) * vrregsize + offset);
@ -230,12 +230,12 @@ fetch_register (int tid, int regno)
if (regaddr == -1) 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); supply_register (regno, buf);
return; 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; errno = 0;
*(PTRACE_XFER_TYPE *) & buf[i] = ptrace (PT_READ_U, tid, *(PTRACE_XFER_TYPE *) & buf[i] = ptrace (PT_READ_U, tid,
@ -257,8 +257,8 @@ supply_vrregset (gdb_vrregset_t *vrregsetp)
int i; int i;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
int num_of_vrregs = tdep->ppc_vrsave_regnum - tdep->ppc_vr0_regnum + 1; int num_of_vrregs = tdep->ppc_vrsave_regnum - tdep->ppc_vr0_regnum + 1;
int vrregsize = REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum); int vrregsize = DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum);
int offset = vrregsize - REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum); int offset = vrregsize - DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum);
for (i = 0; i < num_of_vrregs; i++) for (i = 0; i < num_of_vrregs; i++)
{ {
@ -335,7 +335,7 @@ store_altivec_register (int tid, int regno)
int offset = 0; int offset = 0;
gdb_vrregset_t regs; gdb_vrregset_t regs;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); 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, &regs); ret = ptrace (PTRACE_GETVRREGS, tid, 0, &regs);
if (ret < 0) 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 /* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes
long on the hardware. */ long on the hardware. */
if (regno == (tdep->ppc_vrsave_regnum - 1)) 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, regcache_collect (regno,
regs + (regno - tdep->ppc_vr0_regnum) * vrregsize + offset); regs + (regno - tdep->ppc_vr0_regnum) * vrregsize + offset);
@ -381,7 +381,7 @@ store_register (int tid, int regno)
return; return;
regcache_collect (regno, buf); 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; errno = 0;
ptrace (PT_WRITE_U, tid, (PTRACE_ARG3_TYPE) regaddr, ptrace (PT_WRITE_U, tid, (PTRACE_ARG3_TYPE) regaddr,
@ -410,8 +410,8 @@ fill_vrregset (gdb_vrregset_t *vrregsetp)
int i; int i;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
int num_of_vrregs = tdep->ppc_vrsave_regnum - tdep->ppc_vr0_regnum + 1; int num_of_vrregs = tdep->ppc_vrsave_regnum - tdep->ppc_vr0_regnum + 1;
int vrregsize = REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum); int vrregsize = DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum);
int offset = vrregsize - REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum); int offset = vrregsize - DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum);
for (i = 0; i < num_of_vrregs; i++) for (i = 0; i < num_of_vrregs; i++)
{ {

33
gdb/regcache.c
View file

@ -112,8 +112,8 @@ init_legacy_regcache_descr (struct gdbarch *gdbarch,
to overlap. Ulgh! New targets use gdbarch's register to overlap. Ulgh! New targets use gdbarch's register
read/write and entirely avoid this uglyness. */ read/write and entirely avoid this uglyness. */
descr->register_offset[i] = DEPRECATED_REGISTER_BYTE (i); descr->register_offset[i] = DEPRECATED_REGISTER_BYTE (i);
descr->sizeof_register[i] = REGISTER_RAW_SIZE (i); descr->sizeof_register[i] = DEPRECATED_REGISTER_RAW_SIZE (i);
gdb_assert (MAX_REGISTER_SIZE >= REGISTER_RAW_SIZE (i)); gdb_assert (MAX_REGISTER_SIZE >= DEPRECATED_REGISTER_RAW_SIZE (i));
gdb_assert (MAX_REGISTER_SIZE >= DEPRECATED_REGISTER_VIRTUAL_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 /* If an old style architecture, fill in the remainder of the
register cache descriptor using the register macros. */ register cache descriptor using the register macros. */
/* NOTE: cagney/2003-06-29: If either of DEPRECATED_REGISTER_BYTE or /* 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 totally screwed. Ex: an architecture with raw register sizes
smaller than what DEPRECATED_REGISTER_BYTE indicates; non smaller than what DEPRECATED_REGISTER_BYTE indicates; non
monotonic DEPRECATED_REGISTER_BYTE values. For GDB 6 check for 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) if ((!gdbarch_pseudo_register_read_p (gdbarch)
&& !gdbarch_pseudo_register_write_p (gdbarch) && !gdbarch_pseudo_register_write_p (gdbarch)
&& !gdbarch_register_type_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; descr->legacy_p = 1;
init_legacy_regcache_descr (gdbarch, descr); init_legacy_regcache_descr (gdbarch, descr);
@ -242,7 +243,7 @@ init_regcache_descr (struct gdbarch *gdbarch)
if (DEPRECATED_REGISTER_BYTE_P ()) if (DEPRECATED_REGISTER_BYTE_P ())
gdb_assert (descr->register_offset[i] == DEPRECATED_REGISTER_BYTE (i)); gdb_assert (descr->register_offset[i] == DEPRECATED_REGISTER_BYTE (i));
#if 0 #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)); gdb_assert (descr->sizeof_register[i] == DEPRECATED_REGISTER_VIRTUAL_SIZE (i));
#endif #endif
} }
@ -278,9 +279,9 @@ register_size (struct gdbarch *gdbarch, int regnum)
int size; int size;
gdb_assert (regnum >= 0 && regnum < (NUM_REGS + NUM_PSEUDO_REGS)); gdb_assert (regnum >= 0 && regnum < (NUM_REGS + NUM_PSEUDO_REGS));
size = descr->sizeof_register[regnum]; 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. */ 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 /* NB: Don't check the register's virtual size. It, in say the case
of the MIPS, may not match the raw size! */ of the MIPS, may not match the raw size! */
return size; return size;
@ -661,7 +662,7 @@ deprecated_read_register_bytes (int in_start, char *in_buf, int in_len)
int byte; int byte;
reg_start = DEPRECATED_REGISTER_BYTE (regnum); 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; reg_end = reg_start + reg_len;
if (reg_end <= in_start || in_end <= reg_start) 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); target_fetch_registers (regnum);
memcpy (myaddr, register_buffer (current_regcache, regnum), memcpy (myaddr, register_buffer (current_regcache, regnum),
REGISTER_RAW_SIZE (regnum)); DEPRECATED_REGISTER_RAW_SIZE (regnum));
} }
void void
@ -913,7 +914,7 @@ legacy_write_register_gen (int regnum, const void *myaddr)
registers_ptid = inferior_ptid; registers_ptid = inferior_ptid;
} }
size = REGISTER_RAW_SIZE (regnum); size = DEPRECATED_REGISTER_RAW_SIZE (regnum);
if (real_register (regnum)) if (real_register (regnum))
{ {
@ -1023,7 +1024,7 @@ deprecated_write_register_bytes (int myregstart, char *myaddr, int inlen)
int regstart, regend; int regstart, regend;
regstart = DEPRECATED_REGISTER_BYTE (regnum); 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? */ /* Is this register completely outside the range the user is writing? */
if (myregend <= regstart || regend <= myregstart) if (myregend <= regstart || regend <= myregstart)
@ -1152,9 +1153,9 @@ register_offset_hack (struct gdbarch *gdbarch, int regnum)
ULONGEST ULONGEST
read_register (int regnum) 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); 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 ULONGEST
@ -1185,7 +1186,7 @@ write_register (int regnum, LONGEST val)
{ {
void *buf; void *buf;
int size; int size;
size = REGISTER_RAW_SIZE (regnum); size = DEPRECATED_REGISTER_RAW_SIZE (regnum);
buf = alloca (size); buf = alloca (size);
store_signed_integer (buf, size, (LONGEST) val); store_signed_integer (buf, size, (LONGEST) val);
deprecated_write_register_gen (regnum, buf); deprecated_write_register_gen (regnum, buf);
@ -1551,7 +1552,7 @@ regcache_dump (struct regcache *regcache, struct ui_file *file,
fprintf_unfiltered (file, " %5ld", fprintf_unfiltered (file, " %5ld",
regcache->descr->sizeof_register[regnum]); regcache->descr->sizeof_register[regnum]);
if ((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] || (regcache->descr->sizeof_register[regnum]
!= DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum)) != DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum))
|| (regcache->descr->sizeof_register[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); regcache_raw_read (regcache, regnum, buf);
fprintf_unfiltered (file, "0x"); fprintf_unfiltered (file, "0x");
dump_endian_bytes (file, TARGET_BYTE_ORDER, buf, dump_endian_bytes (file, TARGET_BYTE_ORDER, buf,
REGISTER_RAW_SIZE (regnum)); DEPRECATED_REGISTER_RAW_SIZE (regnum));
} }
} }

4
gdb/remote-e7000.c
View file

@ -882,7 +882,7 @@ fetch_regs_from_dump (int (*nextchar) (), char *want)
internal_error (__FILE__, __LINE__, "failed internal consistency check"); internal_error (__FILE__, __LINE__, "failed internal consistency check");
} }
store_signed_integer (buf, store_signed_integer (buf,
REGISTER_RAW_SIZE (regno), DEPRECATED_REGISTER_RAW_SIZE (regno),
(LONGEST) get_hex (&thischar)); (LONGEST) get_hex (&thischar));
supply_register (regno, buf); supply_register (regno, buf);
break; break;
@ -1964,7 +1964,7 @@ sub2_from_pc (void)
char buf2[200]; char buf2[200];
store_signed_integer (buf, store_signed_integer (buf,
REGISTER_RAW_SIZE (PC_REGNUM), DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM),
read_register (PC_REGNUM) - 2); read_register (PC_REGNUM) - 2);
supply_register (PC_REGNUM, buf); supply_register (PC_REGNUM, buf);
sprintf (buf2, ".PC %s\r", phex_nz (read_register (PC_REGNUM), 0)); sprintf (buf2, ".PC %s\r", phex_nz (read_register (PC_REGNUM), 0));

10
gdb/remote-mips.c
View file

@ -1793,16 +1793,16 @@ mips_wait (ptid_t ptid, struct target_waitstatus *status)
{ {
char buf[MAX_REGISTER_SIZE]; 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); 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 */ 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); 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); supply_register (DEPRECATED_FP_REGNUM, buf);
if (nfields == 9) 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 /* We got the number the register holds, but gdb expects to see a
value in the target byte ordering. */ 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); supply_register (regno, buf);
} }
} }

14
gdb/remote-sim.c
View file

@ -320,14 +320,14 @@ gdbsim_fetch_register (int regno)
memset (buf, 0, MAX_REGISTER_SIZE); memset (buf, 0, MAX_REGISTER_SIZE);
nr_bytes = sim_fetch_register (gdbsim_desc, nr_bytes = sim_fetch_register (gdbsim_desc,
REGISTER_SIM_REGNO (regno), REGISTER_SIM_REGNO (regno),
buf, REGISTER_RAW_SIZE (regno)); buf, DEPRECATED_REGISTER_RAW_SIZE (regno));
if (nr_bytes > 0 && nr_bytes != REGISTER_RAW_SIZE (regno) && warn_user) if (nr_bytes > 0 && nr_bytes != DEPRECATED_REGISTER_RAW_SIZE (regno) && warn_user)
{ {
fprintf_unfiltered (gdb_stderr, fprintf_unfiltered (gdb_stderr,
"Size of register %s (%d/%d) incorrect (%d instead of %d))", "Size of register %s (%d/%d) incorrect (%d instead of %d))",
REGISTER_NAME (regno), REGISTER_NAME (regno),
regno, REGISTER_SIM_REGNO (regno), regno, REGISTER_SIM_REGNO (regno),
nr_bytes, REGISTER_RAW_SIZE (regno)); nr_bytes, DEPRECATED_REGISTER_RAW_SIZE (regno));
warn_user = 0; warn_user = 0;
} }
/* FIXME: cagney/2002-05-27: Should check `nr_bytes == 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); printf_filtered ("gdbsim_fetch_register: %d", regno);
/* FIXME: We could print something more intelligible. */ /* FIXME: We could print something more intelligible. */
dump_mem (buf, REGISTER_RAW_SIZE (regno)); dump_mem (buf, DEPRECATED_REGISTER_RAW_SIZE (regno));
} }
break; break;
} }
@ -364,8 +364,8 @@ gdbsim_store_register (int regno)
deprecated_read_register_gen (regno, tmp); deprecated_read_register_gen (regno, tmp);
nr_bytes = sim_store_register (gdbsim_desc, nr_bytes = sim_store_register (gdbsim_desc,
REGISTER_SIM_REGNO (regno), REGISTER_SIM_REGNO (regno),
tmp, REGISTER_RAW_SIZE (regno)); tmp, DEPRECATED_REGISTER_RAW_SIZE (regno));
if (nr_bytes > 0 && nr_bytes != REGISTER_RAW_SIZE (regno)) if (nr_bytes > 0 && nr_bytes != DEPRECATED_REGISTER_RAW_SIZE (regno))
internal_error (__FILE__, __LINE__, internal_error (__FILE__, __LINE__,
"Register size different to expected"); "Register size different to expected");
/* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0' /* 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); printf_filtered ("gdbsim_store_register: %d", regno);
/* FIXME: We could print something more intelligible. */ /* FIXME: We could print something more intelligible. */
dump_mem (tmp, REGISTER_RAW_SIZE (regno)); dump_mem (tmp, DEPRECATED_REGISTER_RAW_SIZE (regno));
} }
} }
} }

12
gdb/remote-vxmips.c
View file

@ -131,20 +131,20 @@ vx_read_register (int regno)
bcopy (&mips_fpreg_packet[MIPS_R_FP0], bcopy (&mips_fpreg_packet[MIPS_R_FP0],
&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)], &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). */ /* Copy the floating point control/status register (fpcsr). */
bcopy (&mips_fpreg_packet[MIPS_R_FPCSR], bcopy (&mips_fpreg_packet[MIPS_R_FPCSR],
&deprecated_registers[DEPRECATED_REGISTER_BYTE (FCRCS_REGNUM)], &deprecated_registers[DEPRECATED_REGISTER_BYTE (FCRCS_REGNUM)],
REGISTER_RAW_SIZE (FCRCS_REGNUM)); DEPRECATED_REGISTER_RAW_SIZE (FCRCS_REGNUM));
} }
else else
{ {
memset (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)], 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)], 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. */ /* Mark the register cache valid. */
@ -187,13 +187,13 @@ vx_write_register (int regno)
bcopy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)], bcopy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)],
&mips_fpreg_packet[MIPS_R_FP0], &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). */ /* Copy the floating point control/status register (fpcsr). */
bcopy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FCRCS_REGNUM)], bcopy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FCRCS_REGNUM)],
&mips_fpreg_packet[MIPS_R_FPCSR], &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, net_write_registers (mips_fpreg_packet, MIPS_FPREG_PLEN,
PTRACE_SETFPREGS); PTRACE_SETFPREGS);

8
gdb/remote-vxsparc.c
View file

@ -102,9 +102,9 @@ vx_read_register (int regno)
automatically; it greatly simplifies debugging. */ automatically; it greatly simplifies debugging. */
sp = extract_unsigned_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (SP_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)], 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. /* If the target has floating point registers, fetch them.
Otherwise, zero the floating point register values in 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)) if (regno < 0 || (L0_REGNUM <= regno && regno <= I7_REGNUM))
{ {
sp = extract_unsigned_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (SP_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)], write_memory (sp, &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)],
16 * REGISTER_RAW_SIZE (L0_REGNUM)); 16 * DEPRECATED_REGISTER_RAW_SIZE (L0_REGNUM));
} }
} }

12
gdb/remote.c
View file

@ -216,7 +216,7 @@ struct packet_reg
long regnum; /* GDB's internal register number. */ long regnum; /* GDB's internal register number. */
LONGEST pnum; /* Remote protocol register number. */ LONGEST pnum; /* Remote protocol register number. */
int in_g_packet; /* Always part of G packet. */ 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. */ /* 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", error ("Remote sent bad register number %s: %s\nPacket: '%s'\n",
phex_nz (pnum, 0), p, buf); 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; 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); warning ("Remote reply is too short: %s", buf);
supply_register (reg->regnum, regs); 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", error ("Remote sent bad register number %ld: %s\nPacket: '%s'\n",
pnum, p, buf); 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; 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); warning ("Remote reply is too short: %s", buf);
supply_register (reg->regnum, regs); supply_register (reg->regnum, regs);
} }
@ -3548,7 +3548,7 @@ store_register_using_P (int regnum)
sprintf (buf, "P%s=", phex_nz (reg->pnum, 0)); sprintf (buf, "P%s=", phex_nz (reg->pnum, 0));
p = buf + strlen (buf); p = buf + strlen (buf);
regcache_collect (reg->regnum, regp); 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); remote_send (buf, rs->remote_packet_size);
return buf[0] != '\0'; return buf[0] != '\0';

2
gdb/rom68k-rom.c
View file

@ -101,7 +101,7 @@ rom68k_supply_one_register (int regno, unsigned char *hex)
while (is_whitespace (*hex)) while (is_whitespace (*hex))
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); supply_register (regno, regbuf);
return hex; return hex;

6
gdb/rs6000-nat.c
View file

@ -71,7 +71,7 @@
#ifndef ARCH3264 #ifndef ARCH3264
# define ARCH64() 0 # define ARCH64() 0
#else #else
# define ARCH64() (REGISTER_RAW_SIZE (0) == 8) # define ARCH64() (DEPRECATED_REGISTER_RAW_SIZE (0) == 8)
#endif #endif
/* Union of 32-bit and 64-bit ".reg" core file sections. */ /* 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. */ even if the register is really only 32 bits. */
long long buf; long long buf;
rs6000_ptrace64 (PT_READ_GPR, PIDGET (inferior_ptid), nr, 0, (int *)&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); memcpy (addr, &buf, 8);
else else
*addr = buf; *addr = buf;
@ -320,7 +320,7 @@ store_register (int regno)
/* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte /* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte
area, even if the register is really only 32 bits. */ area, even if the register is really only 32 bits. */
long long buf; long long buf;
if (REGISTER_RAW_SIZE (regno) == 8) if (DEPRECATED_REGISTER_RAW_SIZE (regno) == 8)
memcpy (&buf, addr, 8); memcpy (&buf, addr, 8);
else else
buf = *addr; buf = *addr;

30
gdb/rs6000-tdep.c
View file

@ -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) 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]; arg = args[argno];
type = check_typedef (VALUE_TYPE (arg)); 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. */ is a pseudo register. */
int offset = 0; int offset = 0;
int return_regnum = tdep->ppc_gp0_regnum + 3; 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; int reg_part_size;
char *val_buffer; char *val_buffer;
int copied = 0; 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. */ if the value is smaller than the register. */
while (copied < vallen) 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. */ /* It is a pseudo/cooked register. */
regcache_cooked_read (regbuf, return_regnum + i, regcache_cooked_read (regbuf, return_regnum + i,
val_buffer + copied); 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. */ /* return value is copied starting from r3. */
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
&& TYPE_LENGTH (valtype) < REGISTER_RAW_SIZE (3)) && TYPE_LENGTH (valtype) < DEPRECATED_REGISTER_RAW_SIZE (3))
offset = REGISTER_RAW_SIZE (3) - TYPE_LENGTH (valtype); offset = DEPRECATED_REGISTER_RAW_SIZE (3) - TYPE_LENGTH (valtype);
memcpy (valbuf, memcpy (valbuf,
regbuf + DEPRECATED_REGISTER_BYTE (3) + offset, 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++) for (i = fdatap->saved_vr; i < 32; i++)
{ {
deprecated_get_frame_saved_regs (fi)[tdep->ppc_vr0_regnum + i] = vr_addr; 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_ev0_regnum + i] = ev_addr;
deprecated_get_frame_saved_regs (fi)[tdep->ppc_gp0_regnum + i] = ev_addr + 4; 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 get_frame_extra_info (fi)->initial_sp
= extract_unsigned_integer (tmpbuf, = extract_unsigned_integer (tmpbuf,
REGISTER_RAW_SIZE (fdata.alloca_reg)); DEPRECATED_REGISTER_RAW_SIZE (fdata.alloca_reg));
} }
else else
/* NOTE: cagney/2002-04-17: At present the only time /* 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, rs6000_register_convert_to_virtual (int n, struct type *type,
char *from, char *to) 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); deprecated_store_floating (to, TYPE_LENGTH (type), val);
} }
else 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 /* 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, rs6000_register_convert_to_raw (struct type *type, int n,
const char *from, char *to) 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)); 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 else
memcpy (to, from, REGISTER_RAW_SIZE (n)); memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (n));
} }
static void static void
@ -2060,7 +2060,7 @@ e500_store_return_value (struct type *type, char *valbuf)
while (copied < len) while (copied < len)
{ {
int regnum = gdbarch_tdep (current_gdbarch)->ppc_gp0_regnum + 3 + i; 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); char *reg_val_buf = alloca (reg_size);
memcpy (reg_val_buf, valbuf + copied, reg_size); memcpy (reg_val_buf, valbuf + copied, reg_size);

2
gdb/s390-tdep.c
View file

@ -2000,7 +2000,7 @@ s390_pop_frame_regular (struct frame_info *frame)
ULONGEST value; ULONGEST value;
value = read_memory_unsigned_integer (deprecated_get_frame_saved_regs (frame)[regnum], 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); write_register (regnum, value);
} }

54
gdb/sh64-tdep.c
View file

@ -753,7 +753,7 @@ sh64_frame_chain (struct frame_info *frame)
if (gdbarch_tdep (current_gdbarch)->sh_abi == SH_ABI_32) if (gdbarch_tdep (current_gdbarch)->sh_abi == SH_ABI_32)
size = 4; size = 4;
else 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) return read_memory_integer (get_frame_base (frame)
+ get_frame_extra_info (frame)->f_offset, + get_frame_extra_info (frame)->f_offset,
size); 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 gdb_reg_num = translate_insn_rn (pr_regnum, media_mode);
int size = ((gdbarch_tdep (current_gdbarch)->sh_abi == SH_ABI_32) int size = ((gdbarch_tdep (current_gdbarch)->sh_abi == SH_ABI_32)
? 4 ? 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); 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) if (tdep->sh_abi == SH_ABI_32)
size = 4; size = 4;
else 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); deprecated_get_frame_saved_regs (fi)[sp_regnum] = read_memory_integer (deprecated_get_frame_saved_regs (fi)[fp_regnum], size);
} }
else else
@ -1293,7 +1293,7 @@ sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
memcpy (raw_buffer, memcpy (raw_buffer,
(deprecated_generic_find_dummy_frame (get_frame_pc (frame), get_frame_base (frame)) (deprecated_generic_find_dummy_frame (get_frame_pc (frame), get_frame_base (frame))
+ DEPRECATED_REGISTER_BYTE (regnum)), + DEPRECATED_REGISTER_BYTE (regnum)),
REGISTER_RAW_SIZE (regnum)); DEPRECATED_REGISTER_RAW_SIZE (regnum));
return; return;
} }
@ -1306,7 +1306,7 @@ sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
if (regnum == SP_REGNUM) if (regnum == SP_REGNUM)
{ {
if (raw_buffer) /* SP register treated specially */ 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]); deprecated_get_frame_saved_regs (frame)[regnum]);
} }
else else
@ -1322,13 +1322,13 @@ sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
|| live_regnum == PR_REGNUM)) || live_regnum == PR_REGNUM))
size = 4; size = 4;
else else
size = REGISTER_RAW_SIZE (live_regnum); size = DEPRECATED_REGISTER_RAW_SIZE (live_regnum);
if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE) if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
read_memory (deprecated_get_frame_saved_regs (frame)[regnum], raw_buffer, size); read_memory (deprecated_get_frame_saved_regs (frame)[regnum], raw_buffer, size);
else else
read_memory (deprecated_get_frame_saved_regs (frame)[regnum], read_memory (deprecated_get_frame_saved_regs (frame)[regnum],
raw_buffer raw_buffer
+ REGISTER_RAW_SIZE (live_regnum) + DEPRECATED_REGISTER_RAW_SIZE (live_regnum)
- size, - size,
size); size);
} }
@ -1352,7 +1352,7 @@ static CORE_ADDR
sh64_extract_struct_value_address (char *regbuf) sh64_extract_struct_value_address (char *regbuf)
{ {
return (extract_unsigned_integer ((regbuf + DEPRECATED_REGISTER_BYTE (STRUCT_RETURN_REGNUM)), 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 static CORE_ADDR
@ -1392,7 +1392,7 @@ sh64_pop_frame (void)
|| regnum == PR_REGNUM)) || regnum == PR_REGNUM))
size = 4; size = 4;
else else
size = REGISTER_RAW_SIZE (translate_insn_rn (regnum, size = DEPRECATED_REGISTER_RAW_SIZE (translate_insn_rn (regnum,
media_mode)); media_mode));
write_register (regnum, write_register (regnum,
read_memory_integer (deprecated_get_frame_saved_regs (frame)[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) 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) if (len < argreg_size)
{ {
@ -1702,7 +1702,7 @@ sh64_extract_return_value (struct type *type, char *regbuf, char *valbuf)
return_register = DEFAULT_RETURN_REGNUM; return_register = DEFAULT_RETURN_REGNUM;
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
offset = DEPRECATED_REGISTER_BYTE (return_register) + offset = DEPRECATED_REGISTER_BYTE (return_register) +
REGISTER_RAW_SIZE (return_register) - len; DEPRECATED_REGISTER_RAW_SIZE (return_register) - len;
else else
offset = DEPRECATED_REGISTER_BYTE (return_register); offset = DEPRECATED_REGISTER_BYTE (return_register);
memcpy (valbuf, (char *) regbuf + offset, len); 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 return_register = DEFAULT_RETURN_REGNUM;
int offset = 0; int offset = 0;
if (len <= REGISTER_RAW_SIZE (return_register)) if (len <= DEPRECATED_REGISTER_RAW_SIZE (return_register))
{ {
/* Pad with zeros. */ /* 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) 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 else
offset = REGISTER_RAW_SIZE (return_register) - len; offset = DEPRECATED_REGISTER_RAW_SIZE (return_register) - len;
memcpy (buf + offset, valbuf, len); memcpy (buf + offset, valbuf, len);
deprecated_write_register_gen (return_register, buf); 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) if (TARGET_BYTE_ORDER != BFD_ENDIAN_LITTLE)
{ {
/* It is a no-op. */ /* It is a no-op. */
memcpy (to, from, REGISTER_RAW_SIZE (regnum)); memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regnum));
return; return;
} }
@ -2118,7 +2118,7 @@ sh_sh64_register_convert_to_raw (struct type *type, int regnum,
if (TARGET_BYTE_ORDER != BFD_ENDIAN_LITTLE) if (TARGET_BYTE_ORDER != BFD_ENDIAN_LITTLE)
{ {
/* It is a no-op. */ /* It is a no-op. */
memcpy (to, from, REGISTER_RAW_SIZE (regnum)); memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regnum));
return; return;
} }
@ -2155,7 +2155,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
for (portion = 0; portion < 2; portion++) for (portion = 0; portion < 2; portion++)
regcache_raw_read (regcache, base_regnum + portion, regcache_raw_read (regcache, base_regnum + portion,
(temp_buffer (temp_buffer
+ REGISTER_RAW_SIZE (base_regnum) * portion)); + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
/* We must pay attention to the endiannes. */ /* We must pay attention to the endiannes. */
sh_sh64_register_convert_to_virtual (reg_nr, DEPRECATED_REGISTER_VIRTUAL_TYPE (reg_nr), 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++) for (portion = 0; portion < 2; portion++)
regcache_raw_read (regcache, base_regnum + portion, regcache_raw_read (regcache, base_regnum + portion,
((char *) buffer ((char *) buffer
+ REGISTER_RAW_SIZE (base_regnum) * portion)); + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
} }
else if (reg_nr >= FV0_REGNUM 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++) for (portion = 0; portion < 4; portion++)
regcache_raw_read (regcache, base_regnum + portion, regcache_raw_read (regcache, base_regnum + portion,
((char *) buffer ((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 */ /* 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++) for (portion = 0; portion < 2; portion++)
regcache_raw_read (regcache, base_regnum + portion, regcache_raw_read (regcache, base_regnum + portion,
(temp_buffer (temp_buffer
+ REGISTER_RAW_SIZE (base_regnum) * portion)); + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
/* We must pay attention to the endiannes. */ /* We must pay attention to the endiannes. */
sh_sh64_register_convert_to_virtual (reg_nr, DEPRECATED_REGISTER_VIRTUAL_TYPE (reg_nr), 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++) for (portion = 0; portion < 4; portion++)
regcache_raw_read (regcache, base_regnum + portion, regcache_raw_read (regcache, base_regnum + portion,
((char *) buffer ((char *) buffer
+ REGISTER_RAW_SIZE (base_regnum) * portion)); + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
} }
else if (reg_nr == FPSCR_C_REGNUM) 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++) for (portion = 0; portion < 2; portion++)
regcache_raw_write (regcache, base_regnum + portion, regcache_raw_write (regcache, base_regnum + portion,
(temp_buffer (temp_buffer
+ REGISTER_RAW_SIZE (base_regnum) * portion)); + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
} }
else if (reg_nr >= FPP0_REGNUM 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++) for (portion = 0; portion < 2; portion++)
regcache_raw_write (regcache, base_regnum + portion, regcache_raw_write (regcache, base_regnum + portion,
((char *) buffer ((char *) buffer
+ REGISTER_RAW_SIZE (base_regnum) * portion)); + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
} }
else if (reg_nr >= FV0_REGNUM 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++) for (portion = 0; portion < 4; portion++)
regcache_raw_write (regcache, base_regnum + portion, regcache_raw_write (regcache, base_regnum + portion,
((char *) buffer ((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 /* 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, regcache_raw_write (regcache, base_regnum + portion,
(temp_buffer (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, regcache_raw_write (regcache, base_regnum + portion,
((char *) buffer ((char *) buffer
+ REGISTER_RAW_SIZE (base_regnum) * portion)); + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
} }
} }

16
gdb/sparc-nat.c
View file

@ -103,7 +103,7 @@ fetch_inferior_registers (int regno)
deprecated_registers[DEPRECATED_REGISTER_BYTE (0)] = 0; deprecated_registers[DEPRECATED_REGISTER_BYTE (0)] = 0;
memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (1)], 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)] *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PS_REGNUM)]
= inferior_registers.r_ps; = inferior_registers.r_ps;
*(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)] *(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)]; CORE_ADDR sp = *(unsigned int *) & deprecated_registers[DEPRECATED_REGISTER_BYTE (SP_REGNUM)];
target_read_memory (sp, &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_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++) for (i = L0_REGNUM; i <= I7_REGNUM; i++)
deprecated_register_valid[i] = 1; deprecated_register_valid[i] = 1;
} }
@ -160,7 +160,7 @@ fetch_inferior_registers (int regno)
if (deprecated_register_valid[regno]) if (deprecated_register_valid[regno])
printf_unfiltered ("register %d valid and read\n", regno); printf_unfiltered ("register %d valid and read\n", regno);
target_read_memory (sp + i - DEPRECATED_REGISTER_BYTE (L0_REGNUM), 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; deprecated_register_valid[regno] = 1;
} }
} }
@ -234,7 +234,7 @@ store_inferior_registers (int regno)
internal_error (__FILE__, __LINE__, "failed internal consistency check"); internal_error (__FILE__, __LINE__, "failed internal consistency check");
target_write_memory (sp, target_write_memory (sp,
&deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)], &deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)],
16 * REGISTER_RAW_SIZE (L0_REGNUM)); 16 * DEPRECATED_REGISTER_RAW_SIZE (L0_REGNUM));
} }
else else
{ {
@ -242,7 +242,7 @@ store_inferior_registers (int regno)
internal_error (__FILE__, __LINE__, "failed internal consistency check"); internal_error (__FILE__, __LINE__, "failed internal consistency check");
target_write_memory (sp + DEPRECATED_REGISTER_BYTE (regno) - DEPRECATED_REGISTER_BYTE (L0_REGNUM), target_write_memory (sp + DEPRECATED_REGISTER_BYTE (regno) - DEPRECATED_REGISTER_BYTE (L0_REGNUM),
&deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)], &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, memcpy (&inferior_registers.r_g1,
&deprecated_registers[DEPRECATED_REGISTER_BYTE (G1_REGNUM)], &deprecated_registers[DEPRECATED_REGISTER_BYTE (G1_REGNUM)],
15 * REGISTER_RAW_SIZE (G1_REGNUM)); 15 * DEPRECATED_REGISTER_RAW_SIZE (G1_REGNUM));
inferior_registers.r_ps = inferior_registers.r_ps =
*(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PS_REGNUM)]; *(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. */ /* The globals and output registers. */
memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (G1_REGNUM)], &gregs->r_g1, 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 (PS_REGNUM)] = gregs->r_ps;
*(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)] = gregs->r_pc; *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (PC_REGNUM)] = gregs->r_pc;
*(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (DEPRECATED_NPC_REGNUM)] = gregs->r_npc; *(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)]; sp = *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (SP_REGNUM)];
if (0 != target_read_memory (sp, if (0 != target_read_memory (sp,
&deprecated_registers[DEPRECATED_REGISTER_BYTE (L0_REGNUM)], &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 so user can still use gdb */
fprintf_unfiltered (gdb_stderr, fprintf_unfiltered (gdb_stderr,

38
gdb/sparc-tdep.c
View file

@ -815,7 +815,7 @@ sparc_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
if (raw_buffer != NULL) if (raw_buffer != NULL)
{ {
/* Put it back in target format. */ /* 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) if (addrp != NULL)
*addrp = 0; *addrp = 0;
@ -923,14 +923,14 @@ sparc_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
if (raw_buffer != NULL) if (raw_buffer != NULL)
{ {
/* Put it back in target format. */ /* 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) if (addrp != NULL)
*addrp = 0; *addrp = 0;
return; return;
} }
if (raw_buffer != NULL) if (raw_buffer != NULL)
read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum)); read_memory (addr, raw_buffer, DEPRECATED_REGISTER_RAW_SIZE (regnum));
} }
else else
{ {
@ -974,10 +974,10 @@ sparc_push_dummy_frame (void)
/* PC, NPC, CCR, FSR, FPRS, Y, ASI */ /* PC, NPC, CCR, FSR, FPRS, Y, ASI */
deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (PC_REGNUM), deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (PC_REGNUM),
&register_temp[0], &register_temp[0],
REGISTER_RAW_SIZE (PC_REGNUM) * 7); DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM) * 7);
deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (PSTATE_REGNUM), deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (PSTATE_REGNUM),
&register_temp[7 * SPARC_INTREG_SIZE], &register_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. */ /* FIXME: not sure what needs to be saved here. */
} }
else else
@ -985,7 +985,7 @@ sparc_push_dummy_frame (void)
/* Y, PS, WIM, TBR, PC, NPC, FPS, CPS regs */ /* Y, PS, WIM, TBR, PC, NPC, FPS, CPS regs */
deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (Y_REGNUM), deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (Y_REGNUM),
&register_temp[0], &register_temp[0],
REGISTER_RAW_SIZE (Y_REGNUM) * 8); DEPRECATED_REGISTER_RAW_SIZE (Y_REGNUM) * 8);
} }
deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (O0_REGNUM), deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (O0_REGNUM),
@ -1308,29 +1308,29 @@ sparc_pop_frame (void)
if (fsr[PS_REGNUM]) if (fsr[PS_REGNUM])
write_register (PS_REGNUM, write_register (PS_REGNUM,
read_memory_integer (fsr[PS_REGNUM], read_memory_integer (fsr[PS_REGNUM],
REGISTER_RAW_SIZE (PS_REGNUM))); DEPRECATED_REGISTER_RAW_SIZE (PS_REGNUM)));
if (fsr[Y_REGNUM]) if (fsr[Y_REGNUM])
write_register (Y_REGNUM, write_register (Y_REGNUM,
read_memory_integer (fsr[Y_REGNUM], read_memory_integer (fsr[Y_REGNUM],
REGISTER_RAW_SIZE (Y_REGNUM))); DEPRECATED_REGISTER_RAW_SIZE (Y_REGNUM)));
if (fsr[PC_REGNUM]) if (fsr[PC_REGNUM])
{ {
/* Explicitly specified PC (and maybe NPC) -- just restore them. */ /* Explicitly specified PC (and maybe NPC) -- just restore them. */
write_register (PC_REGNUM, write_register (PC_REGNUM,
read_memory_integer (fsr[PC_REGNUM], read_memory_integer (fsr[PC_REGNUM],
REGISTER_RAW_SIZE (PC_REGNUM))); DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM)));
if (fsr[DEPRECATED_NPC_REGNUM]) if (fsr[DEPRECATED_NPC_REGNUM])
write_register (DEPRECATED_NPC_REGNUM, write_register (DEPRECATED_NPC_REGNUM,
read_memory_integer (fsr[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) else if (get_frame_extra_info (frame)->flat)
{ {
if (get_frame_extra_info (frame)->pc_addr) if (get_frame_extra_info (frame)->pc_addr)
pc = PC_ADJUST ((CORE_ADDR) pc = PC_ADJUST ((CORE_ADDR)
read_memory_integer (get_frame_extra_info (frame)->pc_addr, read_memory_integer (get_frame_extra_info (frame)->pc_addr,
REGISTER_RAW_SIZE (PC_REGNUM))); DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM)));
else else
{ {
/* I think this happens only in the innermost frame, if so then /* 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)]; from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)];
to = (char *) &fpregsetp->pr_fr.pr_regs[regi - FP0_REGNUM]; 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)]; from = (char *)&deprecated_registers[DEPRECATED_REGISTER_BYTE (FPS_REGNUM)];
to = (char *) &fpregsetp->pr_fsr; 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); file, 0, 1, 0, Val_pretty_default);
fprintf_filtered (file, "\t(raw 0x"); 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; int idx;
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
idx = j; idx = j;
else 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, "%02x", (unsigned char) raw_buffer[idx]);
} }
fprintf_filtered (file, ")"); fprintf_filtered (file, ")");
@ -2408,10 +2408,10 @@ sparc_store_return_value (struct type *type, char *valbuf)
regno = O0_REGNUM; regno = O0_REGNUM;
/* Add leading zeros to the value. */ /* 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)); memset (buffer, 0, DEPRECATED_REGISTER_RAW_SIZE (regno));
memcpy (buffer + REGISTER_RAW_SIZE (regno) - TYPE_LENGTH (type), valbuf, memcpy (buffer + DEPRECATED_REGISTER_RAW_SIZE (regno) - TYPE_LENGTH (type), valbuf,
TYPE_LENGTH (type)); TYPE_LENGTH (type));
deprecated_write_register_gen (regno, buffer); deprecated_write_register_gen (regno, buffer);
} }
@ -2722,7 +2722,7 @@ sp64_extract_return_value (struct type *type, char *regbuf, char *valbuf,
int bitoffset) int bitoffset)
{ {
int typelen = TYPE_LENGTH (type); 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) if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)
{ {

2
gdb/stack.c
View file

@ -1055,7 +1055,7 @@ frame_info (char *addr_exp, int from_tty)
/* NOTE: cagney/2003-05-22: This is assuming that the /* NOTE: cagney/2003-05-22: This is assuming that the
stack pointer was packed as an unsigned integer. That stack pointer was packed as an unsigned integer. That
may or may not be valid. */ 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 "); printf_filtered (" Previous frame's sp is ");
print_address_numeric (sp, 1, gdb_stdout); print_address_numeric (sp, 1, gdb_stdout);
printf_filtered ("\n"); printf_filtered ("\n");

4
gdb/target.c
View file

@ -1660,11 +1660,11 @@ debug_print_register (const char * func, int regno)
unsigned char buf[MAX_REGISTER_SIZE]; unsigned char buf[MAX_REGISTER_SIZE];
deprecated_read_register_gen (regno, buf); deprecated_read_register_gen (regno, buf);
fprintf_unfiltered (gdb_stdlog, " = "); 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]); 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", fprintf_unfiltered (gdb_stdlog, " 0x%s %s",
paddr_nz (read_register (regno)), paddr_nz (read_register (regno)),

2
gdb/tracepoint.c
View file

@ -1215,7 +1215,7 @@ collect_symbol (struct collection_list *collect, struct symbol *sym,
/* check for doubles stored in two registers */ /* check for doubles stored in two registers */
/* FIXME: how about larger types stored in 3 or more regs? */ /* FIXME: how about larger types stored in 3 or more regs? */
if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT && 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); add_register (collect, reg + 1);
break; break;
case LOC_REF_ARG: case LOC_REF_ARG:

5
gdb/tui/ChangeLog
View file

@ -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> 2003-09-13 Andrew Cagney <cagney@redhat.com>
* tui.h (struct ui_file): Add opaque declaration. * tui.h (struct ui_file): Add opaque declaration.

4
gdb/tui/tuiRegs.c
View file

@ -500,7 +500,7 @@ tuiCheckRegisterValues (struct frame_info *frame)
{ {
int size; int size;
size = REGISTER_RAW_SIZE (dataElementPtr->itemNo); size = DEPRECATED_REGISTER_RAW_SIZE (dataElementPtr->itemNo);
for (j = 0; j < size; j++) for (j = 0; j < size; j++)
((char *) dataElementPtr->value)[j] = rawBuf[j]; ((char *) dataElementPtr->value)[j] = rawBuf[j];
_tuiDisplayRegister ( _tuiDisplayRegister (
@ -763,7 +763,7 @@ _tuiRegValueHasChanged (TuiDataElementPtr dataElement,
if (_tuiGetRegisterRawValue ( if (_tuiGetRegisterRawValue (
dataElement->itemNo, rawBuf, frame) == TUI_SUCCESS) 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++) for (i = 0; (i < size && !hasChanged); i++)
hasChanged = (((char *) dataElement->value)[i] != rawBuf[i]); hasChanged = (((char *) dataElement->value)[i] != rawBuf[i]);

2
gdb/v850-tdep.c
View file

@ -1074,7 +1074,7 @@ v850_extract_return_value (struct type *type, char *regbuf, char *valbuf)
pointed to by R6. */ pointed to by R6. */
return_buffer = return_buffer =
extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (E_V0_REGNUM), 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)); read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
} }

4
gdb/v850ice.c
View file

@ -534,7 +534,7 @@ v850ice_fetch_registers (int regno)
error ("v850ice_fetch_registers (%d): bad value from ICE: %s.", error ("v850ice_fetch_registers (%d): bad value from ICE: %s.",
regno, val); 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); supply_register (regno, val);
} }
@ -560,7 +560,7 @@ v850ice_store_registers (int regno)
} }
regval = extract_unsigned_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)], regval = extract_unsigned_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)],
REGISTER_RAW_SIZE (regno)); DEPRECATED_REGISTER_RAW_SIZE (regno));
strcpy (cmd, "reg "); strcpy (cmd, "reg ");
if (!convert_register (regno, &cmd[4])) if (!convert_register (regno, &cmd[4]))
return; return;

6
gdb/valops.c
View file

@ -627,7 +627,7 @@ value_assign (struct value *toval, struct value *fromval)
{ {
int offset; int offset;
for (reg_offset = value_reg, offset = 0; 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++); reg_offset++);
byte_offset = VALUE_OFFSET (toval) - offset; byte_offset = VALUE_OFFSET (toval) - offset;
} }
@ -645,7 +645,7 @@ value_assign (struct value *toval, struct value *fromval)
/* Copy it in. */ /* Copy it in. */
for (regno = reg_offset, amount_copied = 0; for (regno = reg_offset, amount_copied = 0;
amount_copied < amount_to_copy; 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); frame_register_read (frame, regno, buffer + amount_copied);
/* Modify what needs to be modified. */ /* Modify what needs to be modified. */
@ -662,7 +662,7 @@ value_assign (struct value *toval, struct value *fromval)
/* Copy it out. */ /* Copy it out. */
for (regno = reg_offset, amount_copied = 0; for (regno = reg_offset, amount_copied = 0;
amount_copied < amount_to_copy; 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); put_frame_register (frame, regno, buffer + amount_copied);
} }

2
gdb/vax-tdep.c
View file

@ -280,7 +280,7 @@ static CORE_ADDR
vax_extract_struct_value_address (char *regbuf) vax_extract_struct_value_address (char *regbuf)
{ {
return (extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (0), return (extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (0),
REGISTER_RAW_SIZE (0))); DEPRECATED_REGISTER_RAW_SIZE (0)));
} }
static const unsigned char * static const unsigned char *

4
gdb/vax-tdep.h
View file

@ -22,7 +22,7 @@
#define VAX_TDEP_H #define VAX_TDEP_H
/* Say how long (ordinary) registers are. This is a piece of bogosity /* 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. */ real way to know how big a register is. */
#define VAX_REGISTER_SIZE 4 #define VAX_REGISTER_SIZE 4
@ -33,7 +33,7 @@
register state. */ register state. */
#define VAX_REGISTER_BYTES (VAX_NUM_REGS * 4) #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 #define VAX_MAX_REGISTER_RAW_SIZE 4
/* Largest value DEPRECATED_REGISTER_VIRTUAL_SIZE can have. */ /* Largest value DEPRECATED_REGISTER_VIRTUAL_SIZE can have. */

4
gdb/x86-64-tdep.c
View file

@ -795,8 +795,8 @@ x86_64_store_return_value (struct type *type, struct regcache *regcache,
/* XXX: What about complex floating point types? */ /* XXX: What about complex floating point types? */
else else
{ {
int low_size = REGISTER_RAW_SIZE (0); int low_size = DEPRECATED_REGISTER_RAW_SIZE (0);
int high_size = REGISTER_RAW_SIZE (1); int high_size = DEPRECATED_REGISTER_RAW_SIZE (1);
if (len <= low_size) if (len <= low_size)
regcache_cooked_write_part (regcache, 0, 0, len, valbuf); regcache_cooked_write_part (regcache, 0, 0, len, valbuf);

2
gdb/xstormy16-tdep.c
View file

@ -230,7 +230,7 @@ xstormy16_extract_return_value (struct type *type, char *regbuf, char *valbuf)
pointed to by R2. */ pointed to by R2. */
return_buffer = return_buffer =
extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (E_PTR_RET_REGNUM), 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)); read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
} }