This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
[patch/rfc] registers[] -> deprecated_registers[]
- From: Andrew Cagney <ac131313 at redhat dot com>
- To: gdb-patches at sources dot redhat dot com
- Date: Thu, 07 Nov 2002 17:52:01 -0500
- Subject: [patch/rfc] registers[] -> deprecated_registers[]
Again,
Stuff in the core doesn't need this and architecture / target specific
code needs to stop relying on it.
I'll give this one a few days before committing.
Andrew
2002-11-07 Andrew Cagney <ac131313@redhat.com>
* regcache.h (deprecated_registers): Rename registers. Add
comment mentioning replacements.
* a68v-nat.c, alpha-nat.c, core-sol2.c, hp300ux-nat.c: Update.
* hppab-nat.c, hppah-nat.c, hppam3-nat.c, hpux-thread.c: Update.
* i386-linux-nat.c, i386gnu-nat.c, ia64-aix-nat.c: Update.
* ia64-linux-nat.c, ia64-tdep.c, irix4-nat.c, irix5-nat.c: Update.
* lynx-nat.c, m68k-tdep.c, m68knbsd-nat.c: Update.
* mips-linux-tdep.c, mipsm3-nat.c, mipsv4-nat.c: Update.
* ns32knbsd-nat.c, ppc-bdm.c, ppc-sysv-tdep.c, ptx4-nat.c: Update.
* regcache.c, regcache.h, remote-es.c, remote-sds.c: Update.
* remote-vx68.c, remote-vxmips.c, remote-vxsparc.c: Update.
* rs6000-tdep.c, sol-thread.c, sparc-nat.c, sparc-tdep.c: Update.
* sun3-nat.c, symm-nat.c, v850ice.c: Update.
Index: a68v-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/a68v-nat.c,v
retrieving revision 1.6
diff -u -r1.6 a68v-nat.c
--- a68v-nat.c 7 Nov 2002 15:31:31 -0000 1.6
+++ a68v-nat.c 7 Nov 2002 22:45:42 -0000
@@ -61,11 +61,11 @@
(PTRACE_ARG3_TYPE) & inferior_control_registers,
ptrace_$control_set_m68k);
- bcopy (&inferior_registers, registers, 16 * 4);
- bcopy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)],
+ bcopy (&inferior_registers, &deprecated_registers[0], 16 * 4);
+ bcopy (&inferior_fp_registers, &deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
sizeof inferior_fp_registers.regs);
- *(int *) ®isters[REGISTER_BYTE (PS_REGNUM)] = inferior_control_registers.sr;
- *(int *) ®isters[REGISTER_BYTE (PC_REGNUM)] = inferior_control_registers.pc;
+ *(int *) &deprecated_registers[REGISTER_BYTE (PS_REGNUM)] = inferior_control_registers.sr;
+ *(int *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)] = inferior_control_registers.pc;
}
/* Store our register values back into the inferior.
@@ -94,13 +94,13 @@
(PTRACE_ARG3_TYPE) & inferior_control_registers,
ptrace_$control_set_m68k);
- bcopy (registers, &inferior_registers, sizeof (inferior_registers));
+ bcopy (&deprecated_registers[0], &inferior_registers, sizeof (inferior_registers));
- bcopy (®isters[REGISTER_BYTE (FP0_REGNUM)], inferior_fp_registers.regs,
+ bcopy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)], inferior_fp_registers.regs,
sizeof inferior_fp_registers.regs);
- inferior_control_registers.sr = *(int *) ®isters[REGISTER_BYTE (PS_REGNUM)];
- inferior_control_registers.pc = *(int *) ®isters[REGISTER_BYTE (PC_REGNUM)];
+ inferior_control_registers.sr = *(int *) &deprecated_registers[REGISTER_BYTE (PS_REGNUM)];
+ inferior_control_registers.pc = *(int *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)];
ptrace (PTRACE_SETREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_registers,
Index: alpha-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/alpha-nat.c,v
retrieving revision 1.12
diff -u -r1.12 alpha-nat.c
--- alpha-nat.c 7 Nov 2002 02:40:28 -0000 1.12
+++ alpha-nat.c 7 Nov 2002 22:45:42 -0000
@@ -133,17 +133,17 @@
if (which == 2)
{
/* The FPU Registers. */
- memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)], core_reg_sect, 31 * 8);
- memset (®isters[REGISTER_BYTE (FP0_REGNUM + 31)], 0, 8);
+ memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)], core_reg_sect, 31 * 8);
+ memset (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM + 31)], 0, 8);
memset (&deprecated_register_valid[FP0_REGNUM], 1, 32);
}
else
{
/* The General Registers. */
- memcpy (®isters[REGISTER_BYTE (ALPHA_V0_REGNUM)], core_reg_sect,
+ memcpy (&deprecated_registers[REGISTER_BYTE (ALPHA_V0_REGNUM)], core_reg_sect,
31 * 8);
- memcpy (®isters[REGISTER_BYTE (PC_REGNUM)], core_reg_sect + 31 * 8, 8);
- memset (®isters[REGISTER_BYTE (ALPHA_ZERO_REGNUM)], 0, 8);
+ memcpy (&deprecated_registers[REGISTER_BYTE (PC_REGNUM)], core_reg_sect + 31 * 8, 8);
+ memset (&deprecated_registers[REGISTER_BYTE (ALPHA_ZERO_REGNUM)], 0, 8);
memset (&deprecated_register_valid[ALPHA_V0_REGNUM], 1, 32);
deprecated_register_valid[PC_REGNUM] = 1;
}
@@ -209,10 +209,10 @@
for (regi = 0; regi < 31; regi++)
if ((regno == -1) || (regno == regi))
- *(regp + regi) = *(long *) ®isters[REGISTER_BYTE (regi)];
+ *(regp + regi) = *(long *) &deprecated_registers[REGISTER_BYTE (regi)];
if ((regno == -1) || (regno == PC_REGNUM))
- *(regp + 31) = *(long *) ®isters[REGISTER_BYTE (PC_REGNUM)];
+ *(regp + 31) = *(long *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)];
}
/*
@@ -241,7 +241,7 @@
if ((regno == -1) || (regno == regi))
{
*(regp + regi - FP0_REGNUM) =
- *(long *) ®isters[REGISTER_BYTE (regi)];
+ *(long *) &deprecated_registers[REGISTER_BYTE (regi)];
}
}
}
Index: core-sol2.c
===================================================================
RCS file: /cvs/src/src/gdb/core-sol2.c,v
retrieving revision 1.9
diff -u -r1.9 core-sol2.c
--- core-sol2.c 11 Apr 2002 18:32:51 -0000 1.9
+++ core-sol2.c 7 Nov 2002 22:45:42 -0000
@@ -94,15 +94,15 @@
struct regs *gregs = (struct regs *) core_reg_sect;
/* G0 *always* holds 0. */
- *(int *) ®isters[REGISTER_BYTE (0)] = 0;
+ *(int *) &deprecated_registers[REGISTER_BYTE (0)] = 0;
/* The globals and output registers. */
- memcpy (®isters[REGISTER_BYTE (G1_REGNUM)], &gregs->r_g1,
+ memcpy (&deprecated_registers[REGISTER_BYTE (G1_REGNUM)], &gregs->r_g1,
15 * REGISTER_RAW_SIZE (G1_REGNUM));
- *(int *) ®isters[REGISTER_BYTE (PS_REGNUM)] = gregs->r_ps;
- *(int *) ®isters[REGISTER_BYTE (PC_REGNUM)] = gregs->r_pc;
- *(int *) ®isters[REGISTER_BYTE (NPC_REGNUM)] = gregs->r_npc;
- *(int *) ®isters[REGISTER_BYTE (Y_REGNUM)] = gregs->r_y;
+ *(int *) &deprecated_registers[REGISTER_BYTE (PS_REGNUM)] = gregs->r_ps;
+ *(int *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)] = gregs->r_pc;
+ *(int *) &deprecated_registers[REGISTER_BYTE (NPC_REGNUM)] = gregs->r_npc;
+ *(int *) &deprecated_registers[REGISTER_BYTE (Y_REGNUM)] = gregs->r_y;
/* My best guess at where to get the locals and input
registers is exactly where they usually are, right above
@@ -112,9 +112,9 @@
{
int sp;
- sp = *(int *) ®isters[REGISTER_BYTE (SP_REGNUM)];
+ sp = *(int *) &deprecated_registers[REGISTER_BYTE (SP_REGNUM)];
if (0 != target_read_memory (sp,
- ®isters[REGISTER_BYTE (L0_REGNUM)],
+ &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
16 * REGISTER_RAW_SIZE (L0_REGNUM)))
{
warning ("couldn't read input and local registers from core file\n");
@@ -163,9 +163,9 @@
{
struct fpu *fpuregs = (struct fpu *) core_reg_sect;
- memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)], &fpuregs->fpu_fr,
+ memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)], &fpuregs->fpu_fr,
sizeof (fpuregs->fpu_fr));
- memcpy (®isters[REGISTER_BYTE (FPS_REGNUM)], &fpuregs->fpu_fsr,
+ memcpy (&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)], &fpuregs->fpu_fsr,
sizeof (FPU_FSR_TYPE));
}
else
Index: hp300ux-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/hp300ux-nat.c,v
retrieving revision 1.6
diff -u -r1.6 hp300ux-nat.c
--- hp300ux-nat.c 4 May 2001 04:15:24 -0000 1.6
+++ hp300ux-nat.c 7 Nov 2002 22:45:42 -0000
@@ -161,7 +161,7 @@
{
store_inferior_register_1
(regno, regaddr,
- (*(int *) ®isters[(REGISTER_BYTE (regno)) + i]));
+ (*(int *) &deprecated_registers[(REGISTER_BYTE (regno)) + i]));
regaddr += sizeof (int);
}
}
Index: hppab-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/hppab-nat.c,v
retrieving revision 1.6
diff -u -r1.6 hppab-nat.c
--- hppab-nat.c 4 May 2001 04:15:25 -0000 1.6
+++ hppab-nat.c 7 Nov 2002 22:45:42 -0000
@@ -118,7 +118,7 @@
errno = 0;
if (regno == PCOQ_HEAD_REGNUM || regno == PCOQ_TAIL_REGNUM)
{
- scratch = *(int *) ®isters[REGISTER_BYTE (regno)] | 0x3;
+ scratch = *(int *) &deprecated_registers[REGISTER_BYTE (regno)] | 0x3;
ptrace (PT_WUREGS, PIDGET (inferior_ptid), (PTRACE_ARG3_TYPE) regaddr,
scratch);
if (errno != 0)
@@ -135,7 +135,7 @@
errno = 0;
ptrace (PT_WUREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) regaddr,
- *(int *) ®isters[REGISTER_BYTE (regno) + i]);
+ *(int *) &deprecated_registers[REGISTER_BYTE (regno) + i]);
if (errno != 0)
{
/* Warning, not error, in case we are attached; sometimes the
Index: hppah-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/hppah-nat.c,v
retrieving revision 1.12
diff -u -r1.12 hppah-nat.c
--- hppah-nat.c 24 Oct 2001 02:53:48 -0000 1.12
+++ hppah-nat.c 7 Nov 2002 22:45:42 -0000
@@ -121,7 +121,7 @@
{
CORE_ADDR temp;
- temp = *(CORE_ADDR *)®isters[REGISTER_BYTE (regno)];
+ temp = *(CORE_ADDR *)&deprecated_registers[REGISTER_BYTE (regno)];
/* Set the priv level (stored in the low two bits of the PC. */
temp |= 0x3;
@@ -146,7 +146,7 @@
the high part of IPSW. What will it take for HP to catch a
clue about building sensible interfaces? */
if (regno == IPSW_REGNUM && len == 8)
- *(int *)®isters[REGISTER_BYTE (regno)] = 0;
+ *(int *)&deprecated_registers[REGISTER_BYTE (regno)] = 0;
#endif
for (i = 0; i < len; i += sizeof (int))
@@ -154,7 +154,7 @@
errno = 0;
call_ptrace (PT_WUREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) addr + i,
- *(int *) ®isters[REGISTER_BYTE (regno) + i]);
+ *(int *) &deprecated_registers[REGISTER_BYTE (regno) + i]);
if (errno != 0)
{
/* Warning, not error, in case we are attached; sometimes
Index: hppam3-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/hppam3-nat.c,v
retrieving revision 1.4
diff -u -r1.4 hppam3-nat.c
--- hppam3-nat.c 6 Mar 2001 08:21:08 -0000 1.4
+++ hppam3-nat.c 7 Nov 2002 22:45:42 -0000
@@ -113,15 +113,15 @@
*/
if (regno > 0 && regno < NUM_REGS)
{
- memcpy (&state[regno], ®isters[REGISTER_BYTE (regno)],
+ memcpy (&state[regno], &deprecated_registers[REGISTER_BYTE (regno)],
REGISTER_RAW_SIZE (regno));
}
else
{
for (index = 0; index < NUM_REGS; index++)
- memcpy (&state[index], ®isters[REGISTER_BYTE (index)],
+ memcpy (&state[index], &deprecated_registers[REGISTER_BYTE (index)],
REGISTER_RAW_SIZE (index));
-/* state[index] = registers[REGISTER_BYTE (index)]; */
+/* state[index] = deprecated_registers[REGISTER_BYTE (index)]; */
}
Index: hpux-thread.c
===================================================================
RCS file: /cvs/src/src/gdb/hpux-thread.c,v
retrieving revision 1.12
diff -u -r1.12 hpux-thread.c
--- hpux-thread.c 26 Aug 2002 19:18:33 -0000 1.12
+++ hpux-thread.c 7 Nov 2002 22:45:42 -0000
@@ -357,18 +357,18 @@
else if (regno == SP_REGNUM)
{
write_memory ((CORE_ADDR) & tcb_ptr->static_ctx.sp,
- registers + REGISTER_BYTE (regno),
+ deprecated_registers + REGISTER_BYTE (regno),
REGISTER_RAW_SIZE (regno));
tcb_ptr->static_ctx.sp = (cma__t_hppa_regs *)
- (extract_address (registers + REGISTER_BYTE (regno), REGISTER_RAW_SIZE (regno)) + 160);
+ (extract_address (deprecated_registers + REGISTER_BYTE (regno), REGISTER_RAW_SIZE (regno)) + 160);
}
else if (regno == PC_REGNUM)
write_memory (sp - 20,
- registers + REGISTER_BYTE (regno),
+ deprecated_registers + REGISTER_BYTE (regno),
REGISTER_RAW_SIZE (regno));
else
write_memory (sp + regmap[regno],
- registers + REGISTER_BYTE (regno),
+ deprecated_registers + REGISTER_BYTE (regno),
REGISTER_RAW_SIZE (regno));
}
}
Index: i386-linux-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/i386-linux-nat.c,v
retrieving revision 1.42
diff -u -r1.42 i386-linux-nat.c
--- i386-linux-nat.c 1 Sep 2002 22:05:42 -0000 1.42
+++ i386-linux-nat.c 7 Nov 2002 22:45:42 -0000
@@ -268,7 +268,7 @@
{
errno = 0;
ptrace (PT_WRITE_U, tid, (PTRACE_ARG3_TYPE) regaddr,
- *(PTRACE_XFER_TYPE *) & registers[REGISTER_BYTE (regno) + i]);
+ *(PTRACE_XFER_TYPE *) & deprecated_registers[REGISTER_BYTE (regno) + i]);
regaddr += sizeof (PTRACE_XFER_TYPE);
if (errno != 0)
{
Index: i386gnu-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/i386gnu-nat.c,v
retrieving revision 1.12
diff -u -r1.12 i386gnu-nat.c
--- i386gnu-nat.c 7 Nov 2002 02:40:28 -0000 1.12
+++ i386gnu-nat.c 7 Nov 2002 22:45:42 -0000
@@ -256,7 +256,7 @@
}
#define fill(state, regno) \
- memcpy (REG_ADDR(state, regno), ®isters[REGISTER_BYTE (regno)], \
+ memcpy (REG_ADDR(state, regno), &deprecated_registers[REGISTER_BYTE (regno)], \
REGISTER_RAW_SIZE (regno))
if (regno == -1)
Index: ia64-aix-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/ia64-aix-nat.c,v
retrieving revision 1.3
diff -u -r1.3 ia64-aix-nat.c
--- ia64-aix-nat.c 7 Nov 2002 02:40:28 -0000 1.3
+++ ia64-aix-nat.c 7 Nov 2002 22:45:42 -0000
@@ -85,7 +85,7 @@
#define COPY_REG(_fld_,_regi_) \
if ((regno == -1) || regno == _regi_) \
- memcpy (&(gregsetp->_fld_), ®isters[REGISTER_BYTE (_regi_)], \
+ memcpy (&(gregsetp->_fld_), &deprecated_registers[REGISTER_BYTE (_regi_)], \
REGISTER_RAW_SIZE (_regi_))
for (regi = IA64_GR0_REGNUM; regi <= IA64_GR31_REGNUM; regi++)
@@ -108,10 +108,10 @@
if (regno == IA64_BSP_REGNUM || regno == -1)
{
memcpy (&(gregsetp->__bspstore),
- ®isters[REGISTER_BYTE (IA64_BSP_REGNUM)],
+ &deprecated_registers[REGISTER_BYTE (IA64_BSP_REGNUM)],
REGISTER_RAW_SIZE (IA64_BSP_REGNUM));
- memcpy (®isters[REGISTER_BYTE (IA64_BSPSTORE_REGNUM)],
- ®isters[REGISTER_BYTE (IA64_BSP_REGNUM)],
+ memcpy (&deprecated_registers[REGISTER_BYTE (IA64_BSPSTORE_REGNUM)],
+ &deprecated_registers[REGISTER_BYTE (IA64_BSP_REGNUM)],
REGISTER_RAW_SIZE (IA64_BSP_REGNUM));
}
@@ -153,7 +153,7 @@
{
if ((regno == -1) || (regno == regi))
{
- from = (char *) ®isters[REGISTER_BYTE (regi)];
+ from = (char *) &deprecated_registers[REGISTER_BYTE (regi)];
to = (char *) &(fpregsetp->__fpr[regi - IA64_FR0_REGNUM]);
memcpy (to, from, REGISTER_RAW_SIZE (regi));
}
Index: ia64-linux-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/ia64-linux-nat.c,v
retrieving revision 1.13
diff -u -r1.13 ia64-linux-nat.c
--- ia64-linux-nat.c 24 Feb 2002 22:56:03 -0000 1.13
+++ ia64-linux-nat.c 7 Nov 2002 22:45:42 -0000
@@ -400,7 +400,7 @@
#define COPY_REG(_idx_,_regi_) \
if ((regno == -1) || regno == _regi_) \
- memcpy (regp + _idx_, ®isters[REGISTER_BYTE (_regi_)], \
+ memcpy (regp + _idx_, &deprecated_registers[REGISTER_BYTE (_regi_)], \
REGISTER_RAW_SIZE (_regi_))
for (regi = IA64_GR0_REGNUM; regi <= IA64_GR31_REGNUM; regi++)
@@ -465,7 +465,7 @@
{
if ((regno == -1) || (regno == regi))
{
- from = (char *) ®isters[REGISTER_BYTE (regi)];
+ from = (char *) &rdeprecated_egisters[REGISTER_BYTE (regi)];
to = (char *) &((*fpregsetp)[regi - IA64_FR0_REGNUM]);
memcpy (to, from, REGISTER_RAW_SIZE (regi));
}
Index: ia64-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/ia64-tdep.c,v
retrieving revision 1.35
diff -u -r1.35 ia64-tdep.c
--- ia64-tdep.c 1 Nov 2002 21:21:49 -0000 1.35
+++ ia64-tdep.c 7 Nov 2002 22:45:42 -0000
@@ -1902,7 +1902,7 @@
float_elt_type,
floatreg,
VALUE_CONTENTS (arg) + argoffset,
- ®isters[REGISTER_BYTE (floatreg)]);
+ &deprecated_registers[REGISTER_BYTE (floatreg)]);
floatreg++;
argoffset += TYPE_LENGTH (float_elt_type);
len -= TYPE_LENGTH (float_elt_type);
@@ -1913,7 +1913,7 @@
/* Store the struct return value in r8 if necessary. */
if (struct_return)
{
- store_address (®isters[REGISTER_BYTE (IA64_GR8_REGNUM)],
+ store_address (&deprecated_registers[REGISTER_BYTE (IA64_GR8_REGNUM)],
REGISTER_RAW_SIZE (IA64_GR8_REGNUM),
struct_addr);
}
@@ -1954,7 +1954,7 @@
if (TYPE_CODE (type) == TYPE_CODE_FLT)
{
ia64_register_convert_to_raw (type, IA64_FR8_REGNUM, valbuf,
- ®isters[REGISTER_BYTE (IA64_FR8_REGNUM)]);
+ &deprecated_registers[REGISTER_BYTE (IA64_FR8_REGNUM)]);
target_store_registers (IA64_FR8_REGNUM);
}
else
Index: irix4-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/irix4-nat.c,v
retrieving revision 1.8
diff -u -r1.8 irix4-nat.c
--- irix4-nat.c 6 Mar 2001 08:21:09 -0000 1.8
+++ irix4-nat.c 7 Nov 2002 22:45:42 -0000
@@ -77,19 +77,19 @@
/* same FIXME as above wrt 32 */
for (regi = 0; regi < 32; regi++)
if ((regno == -1) || (regno == regi))
- *(regp + regi) = *(greg_t *) & registers[REGISTER_BYTE (regi)];
+ *(regp + regi) = *(greg_t *) & deprecated_registers[REGISTER_BYTE (regi)];
if ((regno == -1) || (regno == PC_REGNUM))
- gregsetp->gp_pc = *(greg_t *) & registers[REGISTER_BYTE (PC_REGNUM)];
+ gregsetp->gp_pc = *(greg_t *) & deprecated_registers[REGISTER_BYTE (PC_REGNUM)];
if ((regno == -1) || (regno == CAUSE_REGNUM))
- gregsetp->gp_cause = *(greg_t *) & registers[REGISTER_BYTE (CAUSE_REGNUM)];
+ gregsetp->gp_cause = *(greg_t *) & deprecated_registers[REGISTER_BYTE (CAUSE_REGNUM)];
if ((regno == -1) || (regno == HI_REGNUM))
- gregsetp->gp_mdhi = *(greg_t *) & registers[REGISTER_BYTE (HI_REGNUM)];
+ gregsetp->gp_mdhi = *(greg_t *) & deprecated_registers[REGISTER_BYTE (HI_REGNUM)];
if ((regno == -1) || (regno == LO_REGNUM))
- gregsetp->gp_mdlo = *(greg_t *) & registers[REGISTER_BYTE (LO_REGNUM)];
+ gregsetp->gp_mdlo = *(greg_t *) & deprecated_registers[REGISTER_BYTE (LO_REGNUM)];
}
/*
@@ -127,14 +127,14 @@
{
if ((regno == -1) || (regno == regi))
{
- from = (char *) ®isters[REGISTER_BYTE (regi)];
+ from = (char *) &deprecated_registers[REGISTER_BYTE (regi)];
to = (char *) &(fpregsetp->fp_r.fp_regs[regi - FP0_REGNUM]);
memcpy (to, from, REGISTER_RAW_SIZE (regi));
}
}
if ((regno == -1) || (regno == FCRCS_REGNUM))
- fpregsetp->fp_csr = *(unsigned *) ®isters[REGISTER_BYTE (FCRCS_REGNUM)];
+ fpregsetp->fp_csr = *(unsigned *) &deprecated_registers[REGISTER_BYTE (FCRCS_REGNUM)];
}
@@ -184,7 +184,7 @@
return;
}
- memcpy ((char *) registers, core_reg_sect, core_reg_size);
+ memcpy ((char *) deprecated_registers, core_reg_sect, core_reg_size);
}
Index: irix5-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/irix5-nat.c,v
retrieving revision 1.20
diff -u -r1.20 irix5-nat.c
--- irix5-nat.c 7 Nov 2002 15:31:31 -0000 1.20
+++ irix5-nat.c 7 Nov 2002 22:45:42 -0000
@@ -83,27 +83,27 @@
for (regi = 0; regi <= CTX_RA; regi++)
if ((regno == -1) || (regno == regi))
*(regp + regi) =
- extract_signed_integer (®isters[REGISTER_BYTE (regi)],
+ extract_signed_integer (&deprecated_registers[REGISTER_BYTE (regi)],
REGISTER_RAW_SIZE (regi));
if ((regno == -1) || (regno == PC_REGNUM))
*(regp + CTX_EPC) =
- extract_signed_integer (®isters[REGISTER_BYTE (PC_REGNUM)],
+ extract_signed_integer (&deprecated_registers[REGISTER_BYTE (PC_REGNUM)],
REGISTER_RAW_SIZE (PC_REGNUM));
if ((regno == -1) || (regno == CAUSE_REGNUM))
*(regp + CTX_CAUSE) =
- extract_signed_integer (®isters[REGISTER_BYTE (CAUSE_REGNUM)],
+ extract_signed_integer (&deprecated_registers[REGISTER_BYTE (CAUSE_REGNUM)],
REGISTER_RAW_SIZE (CAUSE_REGNUM));
if ((regno == -1) || (regno == HI_REGNUM))
*(regp + CTX_MDHI) =
- extract_signed_integer (®isters[REGISTER_BYTE (HI_REGNUM)],
+ extract_signed_integer (&deprecated_registers[REGISTER_BYTE (HI_REGNUM)],
REGISTER_RAW_SIZE (HI_REGNUM));
if ((regno == -1) || (regno == LO_REGNUM))
*(regp + CTX_MDLO) =
- extract_signed_integer (®isters[REGISTER_BYTE (LO_REGNUM)],
+ extract_signed_integer (&deprecated_registers[REGISTER_BYTE (LO_REGNUM)],
REGISTER_RAW_SIZE (LO_REGNUM));
}
@@ -145,14 +145,14 @@
{
if ((regno == -1) || (regno == regi))
{
- from = (char *) ®isters[REGISTER_BYTE (regi)];
+ from = (char *) &deprecated_registers[REGISTER_BYTE (regi)];
to = (char *) &(fpregsetp->fp_r.fp_regs[regi - FP0_REGNUM]);
memcpy (to, from, REGISTER_RAW_SIZE (regi));
}
}
if ((regno == -1) || (regno == FCRCS_REGNUM))
- fpregsetp->fp_csr = *(unsigned *) ®isters[REGISTER_BYTE (FCRCS_REGNUM)];
+ fpregsetp->fp_csr = *(unsigned *) &deprecated_registers[REGISTER_BYTE (FCRCS_REGNUM)];
}
@@ -198,7 +198,7 @@
{
if (core_reg_size == REGISTER_BYTES)
{
- memcpy ((char *) registers, core_reg_sect, core_reg_size);
+ memcpy ((char *) deprecated_registers, core_reg_sect, core_reg_size);
}
else if (MIPS_REGSIZE == 4 &&
core_reg_size == (2 * MIPS_REGSIZE) * NUM_REGS)
@@ -206,7 +206,7 @@
/* This is a core file from a N32 executable, 64 bits are saved
for all registers. */
char *srcp = core_reg_sect;
- char *dstp = registers;
+ char *dstp = deprecated_registers;
int regno;
for (regno = 0; regno < NUM_REGS; regno++)
Index: lynx-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/lynx-nat.c,v
retrieving revision 1.10
diff -u -r1.10 lynx-nat.c
--- lynx-nat.c 7 Nov 2002 02:40:28 -0000 1.10
+++ lynx-nat.c 7 Nov 2002 22:45:42 -0000
@@ -296,7 +296,7 @@
supply_register (G0_REGNUM, buf);
supply_register (TBR_REGNUM, (char *) &ec.tbr);
- memcpy (®isters[REGISTER_BYTE (G1_REGNUM)], &ec.g1,
+ memcpy (&deprecated_registers[REGISTER_BYTE (G1_REGNUM)], &ec.g1,
4 * REGISTER_RAW_SIZE (G1_REGNUM));
for (i = G1_REGNUM; i <= G1_REGNUM + 3; i++)
deprecated_register_valid[i] = 1;
@@ -307,7 +307,7 @@
supply_register (NPC_REGNUM, (char *) &ec.npc);
supply_register (WIM_REGNUM, (char *) &ec.wim);
- memcpy (®isters[REGISTER_BYTE (O0_REGNUM)], ec.o,
+ memcpy (&deprecated_registers[REGISTER_BYTE (O0_REGNUM)], ec.o,
8 * REGISTER_RAW_SIZE (O0_REGNUM));
for (i = O0_REGNUM; i <= O0_REGNUM + 7; i++)
deprecated_register_valid[i] = 1;
@@ -321,13 +321,13 @@
sp = read_register (SP_REGNUM);
target_read_memory (sp + FRAME_SAVED_I0,
- ®isters[REGISTER_BYTE (I0_REGNUM)],
+ &deprecated_registers[REGISTER_BYTE (I0_REGNUM)],
8 * REGISTER_RAW_SIZE (I0_REGNUM));
for (i = I0_REGNUM; i <= I7_REGNUM; i++)
deprecated_register_valid[i] = 1;
target_read_memory (sp + FRAME_SAVED_L0,
- ®isters[REGISTER_BYTE (L0_REGNUM)],
+ &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
8 * REGISTER_RAW_SIZE (L0_REGNUM));
for (i = L0_REGNUM; i <= L0_REGNUM + 7; i++)
deprecated_register_valid[i] = 1;
@@ -345,7 +345,7 @@
if (errno)
perror_with_name ("ptrace(PTRACE_GETFPREGS)");
- memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)], fc.f.fregs,
+ memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)], fc.f.fregs,
32 * REGISTER_RAW_SIZE (FP0_REGNUM));
for (i = FP0_REGNUM; i <= FP0_REGNUM + 31; i++)
deprecated_register_valid[i] = 1;
@@ -383,7 +383,7 @@
int retval;
ec.tbr = read_register (TBR_REGNUM);
- memcpy (&ec.g1, ®isters[REGISTER_BYTE (G1_REGNUM)],
+ memcpy (&ec.g1, &deprecated_registers[REGISTER_BYTE (G1_REGNUM)],
4 * REGISTER_RAW_SIZE (G1_REGNUM));
ec.psr = read_register (PS_REGNUM);
@@ -392,7 +392,7 @@
ec.npc = read_register (NPC_REGNUM);
ec.wim = read_register (WIM_REGNUM);
- memcpy (ec.o, ®isters[REGISTER_BYTE (O0_REGNUM)],
+ memcpy (ec.o, &deprecated_registers[REGISTER_BYTE (O0_REGNUM)],
8 * REGISTER_RAW_SIZE (O0_REGNUM));
errno = 0;
@@ -414,11 +414,11 @@
if (!deprecated_register_valid[L0_REGNUM + 5])
internal_error (__FILE__, __LINE__, "failed internal consistency check");
target_write_memory (sp + FRAME_SAVED_I0,
- ®isters[REGISTER_BYTE (I0_REGNUM)],
+ &deprecated_registers[REGISTER_BYTE (I0_REGNUM)],
8 * REGISTER_RAW_SIZE (I0_REGNUM));
target_write_memory (sp + FRAME_SAVED_L0,
- ®isters[REGISTER_BYTE (L0_REGNUM)],
+ &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
8 * REGISTER_RAW_SIZE (L0_REGNUM));
}
else if (regno >= L0_REGNUM && regno <= I7_REGNUM)
@@ -432,7 +432,7 @@
regoffset = REGISTER_BYTE (regno) - REGISTER_BYTE (I0_REGNUM)
+ FRAME_SAVED_I0;
target_write_memory (sp + regoffset,
- ®isters[REGISTER_BYTE (regno)],
+ &deprecated_registers[REGISTER_BYTE (regno)],
REGISTER_RAW_SIZE (regno));
}
}
@@ -449,7 +449,7 @@
if (errno)
perror_with_name ("ptrace(PTRACE_GETFPREGS)");
- memcpy (fc.f.fregs, ®isters[REGISTER_BYTE (FP0_REGNUM)],
+ memcpy (fc.f.fregs, &deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
32 * REGISTER_RAW_SIZE (FP0_REGNUM));
fc.fsr = read_register (FPS_REGNUM);
@@ -571,7 +571,7 @@
{
unsigned int reg;
- reg = *(unsigned int *) ®isters[REGISTER_BYTE (regno) + i];
+ reg = *(unsigned int *) &deprecated_registers[REGISTER_BYTE (regno) + i];
errno = 0;
ptrace (ptrace_fun, PIDGET (inferior_ptid),
Index: m68k-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/m68k-tdep.c,v
retrieving revision 1.24
diff -u -r1.24 m68k-tdep.c
--- m68k-tdep.c 24 Aug 2002 00:21:34 -0000 1.24
+++ m68k-tdep.c 7 Nov 2002 22:45:43 -0000
@@ -836,16 +836,16 @@
{
if ((regno == -1) || (regno == regi))
{
- *(regp + regi) = *(int *) ®isters[REGISTER_BYTE (regi)];
+ *(regp + regi) = *(int *) &deprecated_registers[REGISTER_BYTE (regi)];
}
}
if ((regno == -1) || (regno == PS_REGNUM))
{
- *(regp + R_PS) = *(int *) ®isters[REGISTER_BYTE (PS_REGNUM)];
+ *(regp + R_PS) = *(int *) &deprecated_registers[REGISTER_BYTE (PS_REGNUM)];
}
if ((regno == -1) || (regno == PC_REGNUM))
{
- *(regp + R_PC) = *(int *) ®isters[REGISTER_BYTE (PC_REGNUM)];
+ *(regp + R_PC) = *(int *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)];
}
}
@@ -887,22 +887,22 @@
{
if ((regno == -1) || (regno == regi))
{
- from = (char *) ®isters[REGISTER_BYTE (regi)];
+ from = (char *) &deprecated_registers[REGISTER_BYTE (regi)];
to = (char *) &(fpregsetp->f_fpregs[regi - FP0_REGNUM][0]);
memcpy (to, from, REGISTER_RAW_SIZE (regi));
}
}
if ((regno == -1) || (regno == E_FPC_REGNUM))
{
- fpregsetp->f_pcr = *(int *) ®isters[REGISTER_BYTE (E_FPC_REGNUM)];
+ fpregsetp->f_pcr = *(int *) &deprecated_registers[REGISTER_BYTE (E_FPC_REGNUM)];
}
if ((regno == -1) || (regno == E_FPS_REGNUM))
{
- fpregsetp->f_psr = *(int *) ®isters[REGISTER_BYTE (E_FPS_REGNUM)];
+ fpregsetp->f_psr = *(int *) &deprecated_registers[REGISTER_BYTE (E_FPS_REGNUM)];
}
if ((regno == -1) || (regno == E_FPI_REGNUM))
{
- fpregsetp->f_fpiaddr = *(int *) ®isters[REGISTER_BYTE (E_FPI_REGNUM)];
+ fpregsetp->f_fpiaddr = *(int *) &deprecated_registers[REGISTER_BYTE (E_FPI_REGNUM)];
}
}
Index: m68knbsd-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/m68knbsd-nat.c,v
retrieving revision 1.8
diff -u -r1.8 m68knbsd-nat.c
--- m68knbsd-nat.c 7 Nov 2002 15:31:31 -0000 1.8
+++ m68knbsd-nat.c 7 Nov 2002 22:45:43 -0000
@@ -36,12 +36,12 @@
ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_registers, 0);
- memcpy (®isters[REGISTER_BYTE (0)], &inferior_registers,
+ memcpy (&deprecated_registers[REGISTER_BYTE (0)], &inferior_registers,
sizeof (inferior_registers));
ptrace (PT_GETFPREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_fp_registers, 0);
- memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
+ memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
sizeof (inferior_fp_registers));
deprecated_registers_fetched ();
@@ -53,12 +53,12 @@
struct reg inferior_registers;
struct fpreg inferior_fp_registers;
- memcpy (&inferior_registers, ®isters[REGISTER_BYTE (0)],
+ memcpy (&inferior_registers, &deprecated_registers[REGISTER_BYTE (0)],
sizeof (inferior_registers));
ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_registers, 0);
- memcpy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)],
+ memcpy (&inferior_fp_registers, &deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
sizeof (inferior_fp_registers));
ptrace (PT_SETFPREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_fp_registers, 0);
@@ -77,10 +77,10 @@
struct md_core *core_reg = (struct md_core *) core_reg_sect;
/* Integer registers */
- memcpy (®isters[REGISTER_BYTE (0)],
+ memcpy (&deprecated_registers[REGISTER_BYTE (0)],
&core_reg->intreg, sizeof (struct reg));
/* Floating point registers */
- memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)],
+ memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
&core_reg->freg, sizeof (struct fpreg));
}
Index: mips-linux-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/mips-linux-tdep.c,v
retrieving revision 1.5
diff -u -r1.5 mips-linux-tdep.c
--- mips-linux-tdep.c 17 Sep 2002 23:26:01 -0000 1.5
+++ mips-linux-tdep.c 7 Nov 2002 22:45:43 -0000
@@ -132,7 +132,7 @@
if (regno < 32)
{
- src = ®isters[REGISTER_BYTE (regno)];
+ src = &deprecated_registers[REGISTER_BYTE (regno)];
dst = regp + regno + EF_REG0;
memcpy (dst, src, sizeof (elf_greg_t));
return;
@@ -163,7 +163,7 @@
if (regaddr != -1)
{
- src = ®isters[REGISTER_BYTE (regno)];
+ src = &deprecated_registers[REGISTER_BYTE (regno)];
dst = regp + regaddr;
memcpy (dst, src, sizeof (elf_greg_t));
}
@@ -199,13 +199,13 @@
if ((regno >= FP0_REGNUM) && (regno < FP0_REGNUM + 32))
{
- from = (char *) ®isters[REGISTER_BYTE (regno)];
+ from = (char *) &deprecated_registers[REGISTER_BYTE (regno)];
to = (char *) (*fpregsetp + regno - FP0_REGNUM);
memcpy (to, from, REGISTER_RAW_SIZE (regno - FP0_REGNUM));
}
else if (regno == FCRCS_REGNUM)
{
- from = (char *) ®isters[REGISTER_BYTE (regno)];
+ from = (char *) &deprecated_registers[REGISTER_BYTE (regno)];
to = (char *) (*fpregsetp + 32);
memcpy (to, from, REGISTER_RAW_SIZE (regno));
}
Index: mipsm3-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/mipsm3-nat.c,v
retrieving revision 1.5
diff -u -r1.5 mipsm3-nat.c
--- mipsm3-nat.c 7 Nov 2002 15:31:31 -0000 1.5
+++ mipsm3-nat.c 7 Nov 2002 22:45:43 -0000
@@ -122,14 +122,14 @@
* Caller knows that the regs handled in one transaction are of same size.
*/
#define FETCH_REGS(state, regnum, count) \
- memcpy (®isters[REGISTER_BYTE (regnum)], \
+ memcpy (&deprecated_registers[REGISTER_BYTE (regnum)], \
(char *)state+reg_offset[ regnum ], \
count*REGISTER_SIZE)
/* Store COUNT contiguous registers to thread STATE starting from REGNUM */
#define STORE_REGS(state, regnum, count) \
memcpy ((char *)state+reg_offset[ regnum ], \
- ®isters[REGISTER_BYTE (regnum)], \
+ &deprecated_registers[REGISTER_BYTE (regnum)], \
count*REGISTER_SIZE)
#define REGS_ALL -1
@@ -204,7 +204,7 @@
}
/* ZERO_REGNUM is always zero */
- *(int *) registers = 0;
+ *(int *) deprecated_registers = 0;
/* Copy thread saved regs 1..31 to gdb's reg value array
* Luckily, they are contiquous
@@ -259,7 +259,7 @@
/* If the thread does not have saved COPROC1, set regs to zero */
if (!(exc_state.coproc_state & MIPS_STATUS_USE_COP1))
- bzero (®isters[REGISTER_BYTE (FP0_REGNUM)],
+ bzero (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
sizeof (struct mips_float_state));
else
{
@@ -324,7 +324,7 @@
/* Don't allow these to change */
/* ZERO_REGNUM */
- *(int *) registers = 0;
+ *(int *) deprecated_registers = 0;
fetch_inferior_registers (PS_REGNUM);
fetch_inferior_registers (BADVADDR_REGNUM);
@@ -342,8 +342,8 @@
* should go to threads frame pointer. If not true, this
* fails badly!!!!!
*/
- memcpy (®isters[REGISTER_BYTE (MACH_FP_REGNUM)],
- ®isters[REGISTER_BYTE (FP_REGNUM)],
+ memcpy (&deprecated_registers[REGISTER_BYTE (MACH_FP_REGNUM)],
+ &deprecated_registers[REGISTER_BYTE (FP_REGNUM)],
REGISTER_RAW_SIZE (FP_REGNUM));
#endif
Index: mipsv4-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/mipsv4-nat.c,v
retrieving revision 1.6
diff -u -r1.6 mipsv4-nat.c
--- mipsv4-nat.c 6 Mar 2001 08:21:10 -0000 1.6
+++ mipsv4-nat.c 7 Nov 2002 22:45:43 -0000
@@ -75,19 +75,19 @@
for (regi = 0; regi <= 32; regi++)
if ((regno == -1) || (regno == regi))
- *(regp + regi) = *(greg_t *) & registers[REGISTER_BYTE (regi)];
+ *(regp + regi) = *(greg_t *) & deprecated_registers[REGISTER_BYTE (regi)];
if ((regno == -1) || (regno == PC_REGNUM))
- *(regp + CXT_EPC) = *(greg_t *) & registers[REGISTER_BYTE (PC_REGNUM)];
+ *(regp + CXT_EPC) = *(greg_t *) & deprecated_registers[REGISTER_BYTE (PC_REGNUM)];
if ((regno == -1) || (regno == CAUSE_REGNUM))
- *(regp + CXT_CAUSE) = *(greg_t *) & registers[REGISTER_BYTE (CAUSE_REGNUM)];
+ *(regp + CXT_CAUSE) = *(greg_t *) & deprecated_registers[REGISTER_BYTE (CAUSE_REGNUM)];
if ((regno == -1) || (regno == HI_REGNUM))
- *(regp + CXT_MDHI) = *(greg_t *) & registers[REGISTER_BYTE (HI_REGNUM)];
+ *(regp + CXT_MDHI) = *(greg_t *) & deprecated_registers[REGISTER_BYTE (HI_REGNUM)];
if ((regno == -1) || (regno == LO_REGNUM))
- *(regp + CXT_MDLO) = *(greg_t *) & registers[REGISTER_BYTE (LO_REGNUM)];
+ *(regp + CXT_MDLO) = *(greg_t *) & deprecated_registers[REGISTER_BYTE (LO_REGNUM)];
}
/*
@@ -125,14 +125,14 @@
{
if ((regno == -1) || (regno == regi))
{
- from = (char *) ®isters[REGISTER_BYTE (regi)];
+ from = (char *) &deprecated_registers[REGISTER_BYTE (regi)];
to = (char *) &(fpregsetp->fp_r.fp_regs[regi - FP0_REGNUM]);
memcpy (to, from, REGISTER_RAW_SIZE (regi));
}
}
if ((regno == -1) || (regno == FCRCS_REGNUM))
- fpregsetp->fp_csr = *(unsigned *) ®isters[REGISTER_BYTE (FCRCS_REGNUM)];
+ fpregsetp->fp_csr = *(unsigned *) &deprecated_registers[REGISTER_BYTE (FCRCS_REGNUM)];
}
Index: ns32knbsd-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/ns32knbsd-nat.c,v
retrieving revision 1.7
diff -u -r1.7 ns32knbsd-nat.c
--- ns32knbsd-nat.c 7 Nov 2002 15:31:31 -0000 1.7
+++ ns32knbsd-nat.c 7 Nov 2002 22:45:43 -0000
@@ -32,10 +32,10 @@
#include "regcache.h"
#define RF(dst, src) \
- memcpy(®isters[REGISTER_BYTE(dst)], &src, sizeof(src))
+ memcpy(&deprecated_registers[REGISTER_BYTE(dst)], &src, sizeof(src))
#define RS(src, dst) \
- memcpy(&dst, ®isters[REGISTER_BYTE(src)], sizeof(dst))
+ memcpy(&dst, &deprecated_registers[REGISTER_BYTE(src)], sizeof(dst))
void
fetch_inferior_registers (int regno)
Index: ppc-bdm.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-bdm.c,v
retrieving revision 1.14
diff -u -r1.14 ppc-bdm.c
--- ppc-bdm.c 15 Apr 2002 01:09:55 -0000 1.14
+++ ppc-bdm.c 7 Nov 2002 22:45:43 -0000
@@ -295,7 +295,7 @@
&& ((i < FP0_REGNUM) || (i > FPLAST_REGNUM)))
{
/* printf("write valid reg %d\n", bdm_regno); */
- ocd_write_bdm_registers (bdm_regno, registers + REGISTER_BYTE (i), 4);
+ ocd_write_bdm_registers (bdm_regno, deprecated_registers + REGISTER_BYTE (i), 4);
}
/*
else if (i == gdbarch_tdep (current_gdbarch)->ppc_mq_regnum)
Index: ppc-sysv-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-sysv-tdep.c,v
retrieving revision 1.2
diff -u -r1.2 ppc-sysv-tdep.c
--- ppc-sysv-tdep.c 1 Oct 2002 19:26:04 -0000 1.2
+++ ppc-sysv-tdep.c 7 Nov 2002 22:45:43 -0000
@@ -175,7 +175,7 @@
{
char val_buf[4];
store_address (val_buf, 4, struct_addr);
- memcpy (®isters[REGISTER_BYTE (greg)], val_buf, 4);
+ memcpy (&deprecated_registers[REGISTER_BYTE (greg)], val_buf, 4);
greg++;
}
/* Now fill in the registers and stack... */
@@ -192,7 +192,7 @@
if (len > 8)
printf_unfiltered (
"Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
- memcpy (®isters[REGISTER_BYTE (FP0_REGNUM + freg)],
+ memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM + freg)],
VALUE_CONTENTS (arg), len);
freg++;
}
@@ -222,9 +222,9 @@
if ((greg & 1) == 0)
greg++;
- memcpy (®isters[REGISTER_BYTE (greg)],
+ memcpy (&deprecated_registers[REGISTER_BYTE (greg)],
VALUE_CONTENTS (arg), 4);
- memcpy (®isters[REGISTER_BYTE (greg + 1)],
+ memcpy (&deprecated_registers[REGISTER_BYTE (greg + 1)],
VALUE_CONTENTS (arg) + 4, 4);
greg += 2;
}
@@ -247,7 +247,7 @@
}
if (greg <= 10)
{
- memcpy (®isters[REGISTER_BYTE (greg)], val_buf, 4);
+ memcpy (&deprecated_registers[REGISTER_BYTE (greg)], val_buf, 4);
greg++;
}
else
@@ -268,7 +268,7 @@
memcpy (v_val_buf, VALUE_CONTENTS (arg), len);
if (vreg <= 13)
{
- memcpy (®isters[REGISTER_BYTE (tdep->ppc_vr0_regnum
+ memcpy (&deprecated_registers[REGISTER_BYTE (tdep->ppc_vr0_regnum
+ vreg)],
v_val_buf, 16);
vreg++;
Index: ptx4-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/ptx4-nat.c,v
retrieving revision 1.9
diff -u -r1.9 ptx4-nat.c
--- ptx4-nat.c 4 May 2001 04:15:26 -0000 1.9
+++ ptx4-nat.c 7 Nov 2002 22:45:43 -0000
@@ -59,7 +59,7 @@
{
if ((regno == -1) || (regno == regi))
{
- (*gregsetp)[regi] = *(greg_t *) & registers[REGISTER_BYTE (regi)];
+ (*gregsetp)[regi] = *(greg_t *) & deprecated_registers[REGISTER_BYTE (regi)];
}
}
}
Index: regcache.c
===================================================================
RCS file: /cvs/src/src/gdb/regcache.c,v
retrieving revision 1.63
diff -u -r1.63 regcache.c
--- regcache.c 7 Nov 2002 21:43:23 -0000 1.63
+++ regcache.c 7 Nov 2002 22:45:43 -0000
@@ -206,9 +206,9 @@
/* Set the real size of the register cache buffer. */
/* FIXME: cagney/2002-05-22: Should only need to allocate space
for the raw registers. Unfortunatly some code still accesses
- the register array directly using the global registers[].
- Until that code has been purged, play safe and over allocating
- the register buffer. Ulgh! */
+ the register array directly using the global
+ deprecated_registers[]. Until that code has been purged, play
+ safe and over allocating the register buffer. Ulgh! */
descr->sizeof_raw_registers = offset;
/* = descr->register_offset[descr->nr_raw_registers]; */
}
@@ -416,9 +416,9 @@
return regcache->raw_register_valid_p;
}
-/* Global structure containing the current regcache. */
-/* FIXME: cagney/2002-05-11: The two global arrays registers[] and
- deprecated_register_valid[] currently point into this structure. */
+/* FIXME: cagney/2002-05-11: The two global arrays
+ deprecated_registers[] and deprecated_register_valid[] currently
+ point into instances of the register cache. */
struct regcache *current_regcache;
/* NOTE: this is a write-through cache. There is no "dirty" bit for
@@ -428,7 +428,7 @@
/* REGISTERS contains the cached register values (in target byte order). */
-char *registers;
+char *deprecated_registers;
/* DEPRECATED_REGISTER_VALID is 0 if the register needs to be fetched,
1 if it has been fetched, and
@@ -531,9 +531,9 @@
pseudo-register range since pseudo registers are always supplied
using supply_register(). */
/* FIXME: cagney/2001-12-04: This function is DEPRECATED. The target
- code was blatting the registers[] array and then calling this.
- Since targets should only be using supply_register() the need for
- this function/hack is eliminated. */
+ code was blatting the deprecated_registers[] array and then calling
+ this. Since targets should only be using supply_register() the
+ need for this function/hack is eliminated. */
void
deprecated_registers_fetched (void)
@@ -605,7 +605,7 @@
/* FIXME: cagney/2001-08-18: This is just silly. It defeats
the entire register read/write flow of control. Must
resist temptation to return 0xdeadbeef. */
- memcpy (reg_buf, registers + reg_start, reg_len);
+ memcpy (reg_buf, deprecated_registers + reg_start, reg_len);
/* Legacy note: This function, for some reason, allows a NULL
input buffer. If the buffer is NULL, the registers are still
@@ -841,7 +841,8 @@
{
/* For moment, just use underlying legacy code. Ulgh!!! This
silently and very indirectly updates the regcache's buffers
- via the globals deprecated_register_valid[] and registers[]. */
+ via the globals deprecated_register_valid[] and
+ deprecated_registers[]. */
gdb_assert (regcache == current_regcache);
legacy_write_register_gen (regnum, buf);
return;
@@ -954,7 +955,7 @@
Update it from the target before scribbling on it. */
deprecated_read_register_gen (regnum, regbuf);
- memcpy (registers + overlapstart,
+ memcpy (deprecated_registers + overlapstart,
myaddr + (overlapstart - myregstart),
overlapend - overlapstart);
@@ -1367,7 +1368,7 @@
{
current_regcache = regcache_xmalloc (current_gdbarch);
current_regcache->passthrough_p = 1;
- registers = deprecated_grub_regcache_for_registers (current_regcache);
+ deprecated_registers = deprecated_grub_regcache_for_registers (current_regcache);
deprecated_register_valid = deprecated_grub_regcache_for_register_valid (current_regcache);
}
@@ -1649,7 +1650,7 @@
regcache_descr_handle = register_gdbarch_data (init_regcache_descr,
xfree_regcache_descr);
REGISTER_GDBARCH_SWAP (current_regcache);
- register_gdbarch_swap (®isters, sizeof (registers), NULL);
+ register_gdbarch_swap (&deprecated_registers, sizeof (deprecated_registers), NULL);
register_gdbarch_swap (&deprecated_register_valid, sizeof (deprecated_register_valid), NULL);
register_gdbarch_swap (NULL, 0, build_regcache);
Index: regcache.h
===================================================================
RCS file: /cvs/src/src/gdb/regcache.h,v
retrieving revision 1.24
diff -u -r1.24 regcache.h
--- regcache.h 7 Nov 2002 21:43:23 -0000 1.24
+++ regcache.h 7 Nov 2002 22:45:43 -0000
@@ -129,11 +129,6 @@
extern int max_register_size (struct gdbarch *gdbarch);
-/* DEPRECATED: Character array containing an image of the inferior
- programs' registers for the most recently referenced thread. */
-
-extern char *registers;
-
/* Copy/duplicate the contents of a register cache. By default, the
operation is pass-through. Writes to DST and reads from SRC will
go through to the target.
@@ -166,6 +161,13 @@
extern char *deprecated_grub_regcache_for_register_valid (struct regcache *);
extern void deprecated_read_register_gen (int regnum, char *myaddr);
extern void deprecated_write_register_gen (int regnum, char *myaddr);
+
+/* NOTE: cagney/2002-11-07: Character array containing an image of the
+ inferior programs' registers for, possibly, the most recently
+ referenced thread. It should be possible to replace references to
+ this buffer with calls to supply_register() and/or
+ regcache_collect(). */
+extern char *deprecated_registers;
/* Character array containing the current state of each register
(unavailable<0, invalid=0, valid>0) for the most recently
Index: remote-es.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-es.c,v
retrieving revision 1.22
diff -u -r1.22 remote-es.c
--- remote-es.c 11 Jul 2002 13:50:49 -0000 1.22
+++ remote-es.c 7 Nov 2002 22:45:43 -0000
@@ -623,7 +623,7 @@
{
error ("Emulator reply is too short: %s", buf);
}
- registers[r++] = (fromhex (p[k * 2 + 1]) * 16) + fromhex (p[k * 2 + 2]);
+ deprecated_registers[r++] = (fromhex (p[k * 2 + 1]) * 16) + fromhex (p[k * 2 + 2]);
}
}
else
@@ -666,7 +666,7 @@
{
error ("Emulator reply is too short: %s", buf);
}
- registers[r++] = (fromhex (p[i + 0]) * 16) + fromhex (p[i + 1]);
+ deprecated_registers[r++] = (fromhex (p[i + 0]) * 16) + fromhex (p[i + 1]);
i += 2;
}
}
@@ -685,7 +685,7 @@
{
error ("Emulator reply is too short: %s", buf);
}
- registers[r++] = (fromhex (p[i + 0])) * 16 + fromhex (p[i + 1]);
+ deprecated_registers[r++] = (fromhex (p[i + 0])) * 16 + fromhex (p[i + 1]);
i += 2;
}
}
@@ -725,7 +725,7 @@
{
error ("Emulator reply is too short: %s", buf);
}
- registers[r++] = fromhex (buf[k * 2 + 1]) * 16 + fromhex (buf[k * 2 + 2]);
+ deprecated_registers[r++] = fromhex (buf[k * 2 + 1]) * 16 + fromhex (buf[k * 2 + 2]);
}
p = SR_buf;
@@ -735,7 +735,7 @@
{
error ("Emulator reply is too short: %s", buf);
}
- registers[r++] =
+ deprecated_registers[r++] =
fromhex (SR_buf[k * 2 + 1]) * 16 + fromhex (SR_buf[k * 2 + 2]);
}
send_with_reply ("PC", buf, sizeof (buf));
@@ -746,7 +746,7 @@
{
error ("Emulator reply is too short: %s", buf);
}
- registers[r++] = fromhex (buf[k * 2 + 1]) * 16 + fromhex (buf[k * 2 + 2]);
+ deprecated_registers[r++] = fromhex (buf[k * 2 + 1]) * 16 + fromhex (buf[k * 2 + 2]);
}
}
else
@@ -771,7 +771,7 @@
{
error ("Emulator reply is too short: %s", buf);
}
- registers[r++] = fromhex (buf[k * 2 + 1]) * 16 + fromhex (buf[k * 2 + 2]);
+ deprecated_registers[r++] = fromhex (buf[k * 2 + 1]) * 16 + fromhex (buf[k * 2 + 2]);
}
/* fetch STATUS */
@@ -783,7 +783,7 @@
{
error ("Emulator reply is too short: %s", buf);
}
- registers[r++] =
+ deprecated_registers[r++] =
fromhex (SR_buf[k * 2 + 1]) * 16 + fromhex (SR_buf[k * 2 + 2]);
}
@@ -797,7 +797,7 @@
{
error ("Emulator reply is too short: %s", buf);
}
- registers[r++] = fromhex (buf[k * 2 + 1]) * 16 + fromhex (buf[k * 2 + 2]);
+ deprecated_registers[r++] = fromhex (buf[k * 2 + 1]) * 16 + fromhex (buf[k * 2 + 2]);
}
}
}
@@ -827,7 +827,7 @@
int k;
unsigned char *r;
- r = (unsigned char *) registers;
+ r = (unsigned char *) deprecated_registers;
if (regno == -1) /* write all registers */
{
Index: remote-sds.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-sds.c,v
retrieving revision 1.21
diff -u -r1.21 remote-sds.c
--- remote-sds.c 1 Oct 2002 19:26:05 -0000 1.21
+++ remote-sds.c 7 Nov 2002 22:45:43 -0000
@@ -528,7 +528,7 @@
*p++ = 0;
*p++ = 0;
for (i = 0; i < 4 * 6; i++)
- *p++ = registers[i + 4 * 32 + 8 * 32];
+ *p++ = deprecated_registers[i + 4 * 32 + 8 * 32];
for (i = 0; i < 4 * 1; i++)
*p++ = 0;
for (i = 0; i < 4 * 4; i++)
@@ -543,7 +543,7 @@
*p++ = 0;
*p++ = 0;
for (i = 0; i < 4 * 32; i++)
- *p++ = registers[i];
+ *p++ = deprecated_registers[i];
sds_send (buf, p - buf);
Index: remote-vx68.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-vx68.c,v
retrieving revision 1.8
diff -u -r1.8 remote-vx68.c
--- remote-vx68.c 7 Nov 2002 15:31:31 -0000 1.8
+++ remote-vx68.c 7 Nov 2002 22:45:43 -0000
@@ -85,10 +85,10 @@
net_read_registers (mc68k_greg_packet, MC68K_GREG_PLEN, PTRACE_GETREGS);
- bcopy (&mc68k_greg_packet[MC68K_R_D0], registers, 16 * MC68K_GREG_SIZE);
- bcopy (&mc68k_greg_packet[MC68K_R_SR], ®isters[REGISTER_BYTE (PS_REGNUM)],
+ bcopy (&mc68k_greg_packet[MC68K_R_D0], deprecated_registers, 16 * MC68K_GREG_SIZE);
+ bcopy (&mc68k_greg_packet[MC68K_R_SR], &deprecated_registers[REGISTER_BYTE (PS_REGNUM)],
MC68K_GREG_SIZE);
- bcopy (&mc68k_greg_packet[MC68K_R_PC], ®isters[REGISTER_BYTE (PC_REGNUM)],
+ bcopy (&mc68k_greg_packet[MC68K_R_PC], &deprecated_registers[REGISTER_BYTE (PC_REGNUM)],
MC68K_GREG_SIZE);
/* Get floating-point registers, if the target system has them.
@@ -100,17 +100,17 @@
PTRACE_GETFPREGS);
bcopy (&mc68k_fpreg_packet[MC68K_R_FP0],
- ®isters[REGISTER_BYTE (FP0_REGNUM)],
+ &deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
MC68K_FPREG_SIZE * 8);
bcopy (&mc68k_fpreg_packet[MC68K_R_FPCR],
- ®isters[REGISTER_BYTE (FPC_REGNUM)],
+ &deprecated_registers[REGISTER_BYTE (FPC_REGNUM)],
MC68K_FPREG_PLEN - (MC68K_FPREG_SIZE * 8));
}
else
{
- bzero (®isters[REGISTER_BYTE (FP0_REGNUM)],
+ bzero (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
MC68K_FPREG_SIZE * 8);
- bzero (®isters[REGISTER_BYTE (FPC_REGNUM)],
+ bzero (&deprecated_registers[REGISTER_BYTE (FPC_REGNUM)],
MC68K_FPREG_PLEN - (MC68K_FPREG_SIZE * 8));
}
@@ -131,10 +131,10 @@
/* Store general-purpose registers. */
- bcopy (registers, &mc68k_greg_packet[MC68K_R_D0], 16 * MC68K_GREG_SIZE);
- bcopy (®isters[REGISTER_BYTE (PS_REGNUM)],
+ bcopy (deprecated_registers, &mc68k_greg_packet[MC68K_R_D0], 16 * MC68K_GREG_SIZE);
+ bcopy (&deprecated_registers[REGISTER_BYTE (PS_REGNUM)],
&mc68k_greg_packet[MC68K_R_SR], MC68K_GREG_SIZE);
- bcopy (®isters[REGISTER_BYTE (PC_REGNUM)],
+ bcopy (&deprecated_registers[REGISTER_BYTE (PC_REGNUM)],
&mc68k_greg_packet[MC68K_R_PC], MC68K_GREG_SIZE);
net_write_registers (mc68k_greg_packet, MC68K_GREG_PLEN, PTRACE_SETREGS);
@@ -143,10 +143,10 @@
if (target_has_fp)
{
- bcopy (®isters[REGISTER_BYTE (FP0_REGNUM)],
+ bcopy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
&mc68k_fpreg_packet[MC68K_R_FP0],
MC68K_FPREG_SIZE * 8);
- bcopy (®isters[REGISTER_BYTE (FPC_REGNUM)],
+ bcopy (&deprecated_registers[REGISTER_BYTE (FPC_REGNUM)],
&mc68k_fpreg_packet[MC68K_R_FPCR],
MC68K_FPREG_PLEN - (MC68K_FPREG_SIZE * 8));
Index: remote-vxmips.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-vxmips.c,v
retrieving revision 1.8
diff -u -r1.8 remote-vxmips.c
--- remote-vxmips.c 7 Nov 2002 15:31:31 -0000 1.8
+++ remote-vxmips.c 7 Nov 2002 22:45:43 -0000
@@ -103,18 +103,18 @@
/* Copy the general registers. */
- bcopy (&mips_greg_packet[MIPS_R_GP0], ®isters[0], 32 * MIPS_GREG_SIZE);
+ bcopy (&mips_greg_packet[MIPS_R_GP0], &deprecated_registers[0], 32 * MIPS_GREG_SIZE);
/* Copy SR, LO, HI, and PC. */
bcopy (&mips_greg_packet[MIPS_R_SR],
- ®isters[REGISTER_BYTE (PS_REGNUM)], MIPS_GREG_SIZE);
+ &deprecated_registers[REGISTER_BYTE (PS_REGNUM)], MIPS_GREG_SIZE);
bcopy (&mips_greg_packet[MIPS_R_LO],
- ®isters[REGISTER_BYTE (LO_REGNUM)], MIPS_GREG_SIZE);
+ &deprecated_registers[REGISTER_BYTE (LO_REGNUM)], MIPS_GREG_SIZE);
bcopy (&mips_greg_packet[MIPS_R_HI],
- ®isters[REGISTER_BYTE (HI_REGNUM)], MIPS_GREG_SIZE);
+ &deprecated_registers[REGISTER_BYTE (HI_REGNUM)], MIPS_GREG_SIZE);
bcopy (&mips_greg_packet[MIPS_R_PC],
- ®isters[REGISTER_BYTE (PC_REGNUM)], MIPS_GREG_SIZE);
+ &deprecated_registers[REGISTER_BYTE (PC_REGNUM)], MIPS_GREG_SIZE);
/* If the target has floating point registers, fetch them.
Otherwise, zero the floating point register values in
@@ -129,20 +129,20 @@
/* Copy the floating point registers. */
bcopy (&mips_fpreg_packet[MIPS_R_FP0],
- ®isters[REGISTER_BYTE (FP0_REGNUM)],
+ &deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
REGISTER_RAW_SIZE (FP0_REGNUM) * 32);
/* Copy the floating point control/status register (fpcsr). */
bcopy (&mips_fpreg_packet[MIPS_R_FPCSR],
- ®isters[REGISTER_BYTE (FCRCS_REGNUM)],
+ &deprecated_registers[REGISTER_BYTE (FCRCS_REGNUM)],
REGISTER_RAW_SIZE (FCRCS_REGNUM));
}
else
{
- bzero ((char *) ®isters[REGISTER_BYTE (FP0_REGNUM)],
+ bzero ((char *) &deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
REGISTER_RAW_SIZE (FP0_REGNUM) * 32);
- bzero ((char *) ®isters[REGISTER_BYTE (FCRCS_REGNUM)],
+ bzero ((char *) &deprecated_registers[REGISTER_BYTE (FCRCS_REGNUM)],
REGISTER_RAW_SIZE (FCRCS_REGNUM));
}
@@ -162,17 +162,17 @@
/* Store general registers. */
- bcopy (®isters[0], &mips_greg_packet[MIPS_R_GP0], 32 * MIPS_GREG_SIZE);
+ bcopy (&deprecated_registers[0], &mips_greg_packet[MIPS_R_GP0], 32 * MIPS_GREG_SIZE);
/* Copy SR, LO, HI, and PC. */
- bcopy (®isters[REGISTER_BYTE (PS_REGNUM)],
+ bcopy (&deprecated_registers[REGISTER_BYTE (PS_REGNUM)],
&mips_greg_packet[MIPS_R_SR], MIPS_GREG_SIZE);
- bcopy (®isters[REGISTER_BYTE (LO_REGNUM)],
+ bcopy (&deprecated_registers[REGISTER_BYTE (LO_REGNUM)],
&mips_greg_packet[MIPS_R_LO], MIPS_GREG_SIZE);
- bcopy (®isters[REGISTER_BYTE (HI_REGNUM)],
+ bcopy (&deprecated_registers[REGISTER_BYTE (HI_REGNUM)],
&mips_greg_packet[MIPS_R_HI], MIPS_GREG_SIZE);
- bcopy (®isters[REGISTER_BYTE (PC_REGNUM)],
+ bcopy (&deprecated_registers[REGISTER_BYTE (PC_REGNUM)],
&mips_greg_packet[MIPS_R_PC], MIPS_GREG_SIZE);
net_write_registers (mips_greg_packet, MIPS_GREG_PLEN, PTRACE_SETREGS);
@@ -183,13 +183,13 @@
{
/* Copy the floating point data registers. */
- bcopy (®isters[REGISTER_BYTE (FP0_REGNUM)],
+ bcopy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
&mips_fpreg_packet[MIPS_R_FP0],
REGISTER_RAW_SIZE (FP0_REGNUM) * 32);
/* Copy the floating point control/status register (fpcsr). */
- bcopy (®isters[REGISTER_BYTE (FCRCS_REGNUM)],
+ bcopy (&deprecated_registers[REGISTER_BYTE (FCRCS_REGNUM)],
&mips_fpreg_packet[MIPS_R_FPCSR],
REGISTER_RAW_SIZE (FCRCS_REGNUM));
Index: remote-vxsparc.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-vxsparc.c,v
retrieving revision 1.9
diff -u -r1.9 remote-vxsparc.c
--- remote-vxsparc.c 7 Nov 2002 15:31:31 -0000 1.9
+++ remote-vxsparc.c 7 Nov 2002 22:45:43 -0000
@@ -92,18 +92,18 @@
as defined in "tm-sparc.h". */
bcopy (&sparc_greg_packet[SPARC_R_G0],
- ®isters[REGISTER_BYTE (G0_REGNUM)], 32 * SPARC_GREG_SIZE);
+ &deprecated_registers[REGISTER_BYTE (G0_REGNUM)], 32 * SPARC_GREG_SIZE);
bcopy (&sparc_greg_packet[SPARC_R_Y],
- ®isters[REGISTER_BYTE (Y_REGNUM)], 6 * SPARC_GREG_SIZE);
+ &deprecated_registers[REGISTER_BYTE (Y_REGNUM)], 6 * SPARC_GREG_SIZE);
/* Now write the local and in registers to the register window
spill area in the frame. VxWorks does not do this for the
active frame automatically; it greatly simplifies debugging
(FRAME_FIND_SAVED_REGS, in particular, depends on this). */
- sp = extract_address (®isters[REGISTER_BYTE (SP_REGNUM)],
+ sp = extract_address (&deprecated_registers[REGISTER_BYTE (SP_REGNUM)],
REGISTER_RAW_SIZE (SP_REGNUM));
- write_memory (sp, ®isters[REGISTER_BYTE (L0_REGNUM)],
+ write_memory (sp, &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
16 * REGISTER_RAW_SIZE (L0_REGNUM));
/* If the target has floating point registers, fetch them.
@@ -116,14 +116,14 @@
net_read_registers (sparc_fpreg_packet, SPARC_FPREG_PLEN,
PTRACE_GETFPREGS);
bcopy (&sparc_fpreg_packet[SPARC_R_FP0],
- ®isters[REGISTER_BYTE (FP0_REGNUM)], 32 * SPARC_FPREG_SIZE);
+ &deprecated_registers[REGISTER_BYTE (FP0_REGNUM)], 32 * SPARC_FPREG_SIZE);
bcopy (&sparc_fpreg_packet[SPARC_R_FSR],
- ®isters[REGISTER_BYTE (FPS_REGNUM)], 1 * SPARC_FPREG_SIZE);
+ &deprecated_registers[REGISTER_BYTE (FPS_REGNUM)], 1 * SPARC_FPREG_SIZE);
}
else
{
- bzero (®isters[REGISTER_BYTE (FP0_REGNUM)], 32 * SPARC_FPREG_SIZE);
- bzero (®isters[REGISTER_BYTE (FPS_REGNUM)], 1 * SPARC_FPREG_SIZE);
+ bzero (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)], 32 * SPARC_FPREG_SIZE);
+ bzero (&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)], 1 * SPARC_FPREG_SIZE);
}
/* Mark the register cache valid. */
@@ -160,9 +160,9 @@
}
if (in_gp_regs)
{
- bcopy (®isters[REGISTER_BYTE (G0_REGNUM)],
+ bcopy (&deprecated_registers[REGISTER_BYTE (G0_REGNUM)],
&sparc_greg_packet[SPARC_R_G0], 32 * SPARC_GREG_SIZE);
- bcopy (®isters[REGISTER_BYTE (Y_REGNUM)],
+ bcopy (&deprecated_registers[REGISTER_BYTE (Y_REGNUM)],
&sparc_greg_packet[SPARC_R_Y], 6 * SPARC_GREG_SIZE);
net_write_registers (sparc_greg_packet, SPARC_GREG_PLEN, PTRACE_SETREGS);
@@ -172,9 +172,9 @@
if (regno < 0 || (L0_REGNUM <= regno && regno <= I7_REGNUM))
{
- sp = extract_address (®isters[REGISTER_BYTE (SP_REGNUM)],
+ sp = extract_address (&deprecated_registers[REGISTER_BYTE (SP_REGNUM)],
REGISTER_RAW_SIZE (SP_REGNUM));
- write_memory (sp, ®isters[REGISTER_BYTE (L0_REGNUM)],
+ write_memory (sp, &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
16 * REGISTER_RAW_SIZE (L0_REGNUM));
}
}
@@ -183,9 +183,9 @@
if (in_fp_regs && target_has_fp)
{
- bcopy (®isters[REGISTER_BYTE (FP0_REGNUM)],
+ bcopy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
&sparc_fpreg_packet[SPARC_R_FP0], 32 * SPARC_FPREG_SIZE);
- bcopy (®isters[REGISTER_BYTE (FPS_REGNUM)],
+ bcopy (&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)],
&sparc_fpreg_packet[SPARC_R_FSR], 1 * SPARC_FPREG_SIZE);
net_write_registers (sparc_fpreg_packet, SPARC_FPREG_PLEN,
Index: rs6000-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/rs6000-tdep.c,v
retrieving revision 1.89
diff -u -r1.89 rs6000-tdep.c
--- rs6000-tdep.c 2 Nov 2002 14:59:10 -0000 1.89
+++ rs6000-tdep.c 7 Nov 2002 22:45:44 -0000
@@ -995,7 +995,7 @@
addr = prev_sp + fdata.gpr_offset;
for (ii = fdata.saved_gpr; ii <= 31; ++ii)
{
- read_memory (addr, ®isters[REGISTER_BYTE (ii)], wordsize);
+ read_memory (addr, &deprecated_registers[REGISTER_BYTE (ii)], wordsize);
addr += wordsize;
}
}
@@ -1005,7 +1005,7 @@
addr = prev_sp + fdata.fpr_offset;
for (ii = fdata.saved_fpr; ii <= 31; ++ii)
{
- read_memory (addr, ®isters[REGISTER_BYTE (ii + FP0_REGNUM)], 8);
+ read_memory (addr, &deprecated_registers[REGISTER_BYTE (ii + FP0_REGNUM)], 8);
addr += 8;
}
}
@@ -1122,7 +1122,7 @@
printf_unfiltered (
"Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
- memcpy (®isters[REGISTER_BYTE (FP0_REGNUM + 1 + f_argno)],
+ memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM + 1 + f_argno)],
VALUE_CONTENTS (arg),
len);
++f_argno;
@@ -1134,8 +1134,8 @@
/* Argument takes more than one register. */
while (argbytes < len)
{
- memset (®isters[REGISTER_BYTE (ii + 3)], 0, reg_size);
- memcpy (®isters[REGISTER_BYTE (ii + 3)],
+ memset (&deprecated_registers[REGISTER_BYTE (ii + 3)], 0, reg_size);
+ memcpy (&deprecated_registers[REGISTER_BYTE (ii + 3)],
((char *) VALUE_CONTENTS (arg)) + argbytes,
(len - argbytes) > reg_size
? reg_size : len - argbytes);
@@ -1151,8 +1151,8 @@
{
/* Argument can fit in one register. No problem. */
int adj = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? reg_size - len : 0;
- memset (®isters[REGISTER_BYTE (ii + 3)], 0, reg_size);
- memcpy ((char *)®isters[REGISTER_BYTE (ii + 3)] + adj,
+ memset (&deprecated_registers[REGISTER_BYTE (ii + 3)], 0, reg_size);
+ memcpy ((char *)&deprecated_registers[REGISTER_BYTE (ii + 3)] + adj,
VALUE_CONTENTS (arg), len);
}
++argno;
@@ -1234,7 +1234,7 @@
printf_unfiltered (
"Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
- memcpy (®isters[REGISTER_BYTE (FP0_REGNUM + 1 + f_argno)],
+ memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM + 1 + f_argno)],
VALUE_CONTENTS (arg),
len);
++f_argno;
@@ -2474,7 +2474,7 @@
/* Number of total registers (the sum of nregs and npregs). */
int num_tot_regs;
- /* Table of register names; registers[R] is the name of the register
+ /* Table of register names; deprecated_registers[R] is the name of the register
number R. */
const struct reg *regs;
};
Index: sol-thread.c
===================================================================
RCS file: /cvs/src/src/gdb/sol-thread.c,v
retrieving revision 1.30
diff -u -r1.30 sol-thread.c
--- sol-thread.c 26 Aug 2002 19:18:33 -0000 1.30
+++ sol-thread.c 7 Nov 2002 22:45:44 -0000
@@ -648,7 +648,7 @@
{ /* Not writing all the regs */
/* save new register value */
char* old_value = (char*) alloca (REGISTER_SIZE);
- memcpy (old_value, ®isters[REGISTER_BYTE (regno)], REGISTER_SIZE);
+ memcpy (old_value, &deprecated_registers[REGISTER_BYTE (regno)], REGISTER_SIZE);
val = p_td_thr_getgregs (&thandle, gregset);
if (val != TD_OK)
@@ -660,7 +660,7 @@
td_err_string (val));
/* restore new register value */
- memcpy (®isters[REGISTER_BYTE (regno)], old_value, REGISTER_SIZE);
+ memcpy (&deprecated_registers[REGISTER_BYTE (regno)], old_value, REGISTER_SIZE);
#if 0
/* thread_db doesn't seem to handle this right */
Index: sparc-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/sparc-nat.c,v
retrieving revision 1.14
diff -u -r1.14 sparc-nat.c
--- sparc-nat.c 7 Nov 2002 02:40:28 -0000 1.14
+++ sparc-nat.c 7 Nov 2002 22:45:44 -0000
@@ -79,13 +79,13 @@
(PTRACE_ARG3_TYPE) & inferior_registers, 0))
perror ("ptrace_getregs");
- registers[REGISTER_BYTE (0)] = 0;
- memcpy (®isters[REGISTER_BYTE (1)], &inferior_registers.r_g1,
+ deprecated_registers[REGISTER_BYTE (0)] = 0;
+ memcpy (&deprecated_registers[REGISTER_BYTE (1)], &inferior_registers.r_g1,
15 * REGISTER_RAW_SIZE (G0_REGNUM));
- *(int *) ®isters[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps;
- *(int *) ®isters[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc;
- *(int *) ®isters[REGISTER_BYTE (NPC_REGNUM)] = inferior_registers.r_npc;
- *(int *) ®isters[REGISTER_BYTE (Y_REGNUM)] = inferior_registers.r_y;
+ *(int *) &deprecated_registers[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps;
+ *(int *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc;
+ *(int *) &deprecated_registers[REGISTER_BYTE (NPC_REGNUM)] = inferior_registers.r_npc;
+ *(int *) &deprecated_registers[REGISTER_BYTE (Y_REGNUM)] = inferior_registers.r_y;
for (i = G0_REGNUM; i <= O7_REGNUM; i++)
deprecated_register_valid[i] = 1;
@@ -109,9 +109,9 @@
(PTRACE_ARG3_TYPE) & inferior_fp_registers,
0))
perror ("ptrace_getfpregs");
- memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
+ memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
sizeof inferior_fp_registers.fpu_fr);
- memcpy (®isters[REGISTER_BYTE (FPS_REGNUM)],
+ memcpy (&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)],
&inferior_fp_registers.Fpu_fsr,
sizeof (FPU_FSR_TYPE));
for (i = FP0_REGNUM; i <= FP0_REGNUM + 31; i++)
@@ -123,20 +123,20 @@
all (16 ptrace calls!) if we really need them. */
if (regno == -1)
{
- CORE_ADDR sp = *(unsigned int *) & registers[REGISTER_BYTE (SP_REGNUM)];
- target_read_memory (sp, ®isters[REGISTER_BYTE (L0_REGNUM)],
+ CORE_ADDR sp = *(unsigned int *) & deprecated_registers[REGISTER_BYTE (SP_REGNUM)];
+ target_read_memory (sp, &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
16 * REGISTER_RAW_SIZE (L0_REGNUM));
for (i = L0_REGNUM; i <= I7_REGNUM; i++)
deprecated_register_valid[i] = 1;
}
else if (regno >= L0_REGNUM && regno <= I7_REGNUM)
{
- CORE_ADDR sp = *(unsigned int *) & registers[REGISTER_BYTE (SP_REGNUM)];
+ CORE_ADDR sp = *(unsigned int *) & deprecated_registers[REGISTER_BYTE (SP_REGNUM)];
i = REGISTER_BYTE (regno);
if (deprecated_register_valid[regno])
printf_unfiltered ("register %d valid and read\n", regno);
target_read_memory (sp + i - REGISTER_BYTE (L0_REGNUM),
- ®isters[i], REGISTER_RAW_SIZE (regno));
+ &deprecated_registers[i], REGISTER_RAW_SIZE (regno));
deprecated_register_valid[regno] = 1;
}
}
@@ -195,14 +195,14 @@
if (wanna_store & STACK_REGS)
{
- CORE_ADDR sp = *(unsigned int *) & registers[REGISTER_BYTE (SP_REGNUM)];
+ CORE_ADDR sp = *(unsigned int *) & deprecated_registers[REGISTER_BYTE (SP_REGNUM)];
if (regno < 0 || regno == SP_REGNUM)
{
if (!deprecated_register_valid[L0_REGNUM + 5])
internal_error (__FILE__, __LINE__, "failed internal consistency check");
target_write_memory (sp,
- ®isters[REGISTER_BYTE (L0_REGNUM)],
+ &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
16 * REGISTER_RAW_SIZE (L0_REGNUM));
}
else
@@ -210,7 +210,7 @@
if (!deprecated_register_valid[regno])
internal_error (__FILE__, __LINE__, "failed internal consistency check");
target_write_memory (sp + REGISTER_BYTE (regno) - REGISTER_BYTE (L0_REGNUM),
- ®isters[REGISTER_BYTE (regno)],
+ &deprecated_registers[REGISTER_BYTE (regno)],
REGISTER_RAW_SIZE (regno));
}
@@ -221,17 +221,17 @@
if (!deprecated_register_valid[G1_REGNUM])
internal_error (__FILE__, __LINE__, "failed internal consistency check");
- memcpy (&inferior_registers.r_g1, ®isters[REGISTER_BYTE (G1_REGNUM)],
+ memcpy (&inferior_registers.r_g1, &deprecated_registers[REGISTER_BYTE (G1_REGNUM)],
15 * REGISTER_RAW_SIZE (G1_REGNUM));
inferior_registers.r_ps =
- *(int *) ®isters[REGISTER_BYTE (PS_REGNUM)];
+ *(int *) &deprecated_registers[REGISTER_BYTE (PS_REGNUM)];
inferior_registers.r_pc =
- *(int *) ®isters[REGISTER_BYTE (PC_REGNUM)];
+ *(int *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)];
inferior_registers.r_npc =
- *(int *) ®isters[REGISTER_BYTE (NPC_REGNUM)];
+ *(int *) &deprecated_registers[REGISTER_BYTE (NPC_REGNUM)];
inferior_registers.r_y =
- *(int *) ®isters[REGISTER_BYTE (Y_REGNUM)];
+ *(int *) &deprecated_registers[REGISTER_BYTE (Y_REGNUM)];
if (0 != ptrace (PTRACE_SETREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_registers, 0))
@@ -242,10 +242,10 @@
{
if (!deprecated_register_valid[FP0_REGNUM + 9])
internal_error (__FILE__, __LINE__, "failed internal consistency check");
- memcpy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)],
+ memcpy (&inferior_fp_registers, &deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
sizeof inferior_fp_registers.fpu_fr);
memcpy (&inferior_fp_registers.Fpu_fsr,
- ®isters[REGISTER_BYTE (FPS_REGNUM)], sizeof (FPU_FSR_TYPE));
+ &deprecated_registers[REGISTER_BYTE (FPS_REGNUM)], sizeof (FPU_FSR_TYPE));
if (0 !=
ptrace (PTRACE_SETFPREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_fp_registers, 0))
@@ -277,15 +277,15 @@
#define gregs ((struct regs *)core_reg_sect)
/* G0 *always* holds 0. */
- *(int *) ®isters[REGISTER_BYTE (0)] = 0;
+ *(int *) &deprecated_registers[REGISTER_BYTE (0)] = 0;
/* The globals and output registers. */
- memcpy (®isters[REGISTER_BYTE (G1_REGNUM)], &gregs->r_g1,
+ memcpy (&deprecated_registers[REGISTER_BYTE (G1_REGNUM)], &gregs->r_g1,
15 * REGISTER_RAW_SIZE (G1_REGNUM));
- *(int *) ®isters[REGISTER_BYTE (PS_REGNUM)] = gregs->r_ps;
- *(int *) ®isters[REGISTER_BYTE (PC_REGNUM)] = gregs->r_pc;
- *(int *) ®isters[REGISTER_BYTE (NPC_REGNUM)] = gregs->r_npc;
- *(int *) ®isters[REGISTER_BYTE (Y_REGNUM)] = gregs->r_y;
+ *(int *) &deprecated_registers[REGISTER_BYTE (PS_REGNUM)] = gregs->r_ps;
+ *(int *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)] = gregs->r_pc;
+ *(int *) &deprecated_registers[REGISTER_BYTE (NPC_REGNUM)] = gregs->r_npc;
+ *(int *) &deprecated_registers[REGISTER_BYTE (Y_REGNUM)] = gregs->r_y;
/* My best guess at where to get the locals and input
registers is exactly where they usually are, right above
@@ -295,8 +295,8 @@
{
int sp;
- sp = *(int *) ®isters[REGISTER_BYTE (SP_REGNUM)];
- if (0 != target_read_memory (sp, ®isters[REGISTER_BYTE (L0_REGNUM)],
+ sp = *(int *) &deprecated_registers[REGISTER_BYTE (SP_REGNUM)];
+ if (0 != target_read_memory (sp, &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
16 * REGISTER_RAW_SIZE (L0_REGNUM)))
{
/* fprintf_unfiltered so user can still use gdb */
@@ -313,9 +313,9 @@
#define fpuregs ((struct fpu *) core_reg_sect)
if (core_reg_size >= sizeof (struct fpu))
{
- memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)], fpuregs->fpu_regs,
+ memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)], fpuregs->fpu_regs,
sizeof (fpuregs->fpu_regs));
- memcpy (®isters[REGISTER_BYTE (FPS_REGNUM)], &fpuregs->fpu_fsr,
+ memcpy (&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)], &fpuregs->fpu_fsr,
sizeof (FPU_FSR_TYPE));
}
else
Index: sparc-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/sparc-tdep.c,v
retrieving revision 1.41
diff -u -r1.41 sparc-tdep.c
--- sparc-tdep.c 5 Nov 2002 20:43:35 -0000 1.41
+++ sparc-tdep.c 7 Nov 2002 22:45:44 -0000
@@ -1727,7 +1727,7 @@
{
if ((regno == -1) || (regno == regi))
{
- from = (char *) ®isters[REGISTER_BYTE (regi)];
+ from = (char *) &deprecated_registers[REGISTER_BYTE (regi)];
to = (char *) &fpregsetp->pr_fr.pr_regs[regi - FP0_REGNUM];
memcpy (to, from, REGISTER_RAW_SIZE (regi));
}
@@ -1736,7 +1736,7 @@
if (!(GDB_TARGET_IS_SPARC64)) /* FIXME: does Sparc64 have this register? */
if ((regno == -1) || (regno == FPS_REGNUM))
{
- from = (char *)®isters[REGISTER_BYTE (FPS_REGNUM)];
+ from = (char *)&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)];
to = (char *) &fpregsetp->pr_fsr;
memcpy (to, from, REGISTER_RAW_SIZE (FPS_REGNUM));
}
Index: sun3-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/sun3-nat.c,v
retrieving revision 1.9
diff -u -r1.9 sun3-nat.c
--- sun3-nat.c 7 Nov 2002 15:31:31 -0000 1.9
+++ sun3-nat.c 7 Nov 2002 22:45:44 -0000
@@ -45,15 +45,15 @@
ptrace (PTRACE_GETFPREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_fp_registers);
- memcpy (registers, &inferior_registers, 16 * 4);
+ memcpy (deprecated_registers, &inferior_registers, 16 * 4);
if (FP0_REGNUM >= 0)
- memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
+ memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
sizeof inferior_fp_registers.fps_regs);
- *(int *) ®isters[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps;
- *(int *) ®isters[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc;
+ *(int *) &deprecated_registers[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps;
+ *(int *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc;
if (FP0_REGNUM >= 0)
- memcpy (®isters[REGISTER_BYTE (FPC_REGNUM)],
+ memcpy (&deprecated_registers[REGISTER_BYTE (FPC_REGNUM)],
&inferior_fp_registers.fps_control,
sizeof inferior_fp_registers -
sizeof inferior_fp_registers.fps_regs);
@@ -69,17 +69,17 @@
struct regs inferior_registers;
struct fp_status inferior_fp_registers;
- memcpy (&inferior_registers, registers, 16 * 4);
+ memcpy (&inferior_registers, deprecated_registers, 16 * 4);
if (FP0_REGNUM >= 0)
- memcpy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)],
+ memcpy (&inferior_fp_registers, &deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
sizeof inferior_fp_registers.fps_regs);
- inferior_registers.r_ps = *(int *) ®isters[REGISTER_BYTE (PS_REGNUM)];
- inferior_registers.r_pc = *(int *) ®isters[REGISTER_BYTE (PC_REGNUM)];
+ inferior_registers.r_ps = *(int *) &deprecated_registers[REGISTER_BYTE (PS_REGNUM)];
+ inferior_registers.r_pc = *(int *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)];
if (FP0_REGNUM >= 0)
memcpy (&inferior_fp_registers.fps_control,
- ®isters[REGISTER_BYTE (FPC_REGNUM)],
+ &deprecated_registers[REGISTER_BYTE (FPC_REGNUM)],
sizeof inferior_fp_registers -
sizeof inferior_fp_registers.fps_regs);
@@ -116,7 +116,7 @@
if (core_reg_size < sizeof (struct regs))
error ("Can't find registers in core file");
- memcpy (registers, (char *) regs, 16 * 4);
+ memcpy (deprecated_registers, (char *) regs, 16 * 4);
supply_register (PS_REGNUM, (char *) ®s->r_ps);
supply_register (PC_REGNUM, (char *) ®s->r_pc);
@@ -130,10 +130,10 @@
{
if (FP0_REGNUM >= 0)
{
- memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)],
+ memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
fpustruct->f_fpstatus.fps_regs,
sizeof fpustruct->f_fpstatus.fps_regs);
- memcpy (®isters[REGISTER_BYTE (FPC_REGNUM)],
+ memcpy (&deprecated_registers[REGISTER_BYTE (FPC_REGNUM)],
&fpustruct->f_fpstatus.fps_control,
sizeof fpustruct->f_fpstatus -
sizeof fpustruct->f_fpstatus.fps_regs);
Index: symm-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/symm-nat.c,v
retrieving revision 1.12
diff -u -r1.12 symm-nat.c
--- symm-nat.c 7 Nov 2002 15:31:31 -0000 1.12
+++ symm-nat.c 7 Nov 2002 22:45:44 -0000
@@ -68,29 +68,29 @@
to the registers array to solve this properly. */
mptrace (XPT_RREGS, PIDGET (inferior_ptid), (PTRACE_ARG3_TYPE) & regs, 0);
- regs.pr_eax = *(int *) ®isters[REGISTER_BYTE (0)];
- regs.pr_ebx = *(int *) ®isters[REGISTER_BYTE (5)];
- regs.pr_ecx = *(int *) ®isters[REGISTER_BYTE (2)];
- regs.pr_edx = *(int *) ®isters[REGISTER_BYTE (1)];
- regs.pr_esi = *(int *) ®isters[REGISTER_BYTE (6)];
- regs.pr_edi = *(int *) ®isters[REGISTER_BYTE (7)];
- regs.pr_esp = *(int *) ®isters[REGISTER_BYTE (14)];
- regs.pr_ebp = *(int *) ®isters[REGISTER_BYTE (15)];
- regs.pr_eip = *(int *) ®isters[REGISTER_BYTE (16)];
- regs.pr_flags = *(int *) ®isters[REGISTER_BYTE (17)];
+ regs.pr_eax = *(int *) &deprecated_registers[REGISTER_BYTE (0)];
+ regs.pr_ebx = *(int *) &deprecated_registers[REGISTER_BYTE (5)];
+ regs.pr_ecx = *(int *) &deprecated_registers[REGISTER_BYTE (2)];
+ regs.pr_edx = *(int *) &deprecated_registers[REGISTER_BYTE (1)];
+ regs.pr_esi = *(int *) &deprecated_registers[REGISTER_BYTE (6)];
+ regs.pr_edi = *(int *) &deprecated_registers[REGISTER_BYTE (7)];
+ regs.pr_esp = *(int *) &deprecated_registers[REGISTER_BYTE (14)];
+ regs.pr_ebp = *(int *) &deprecated_registers[REGISTER_BYTE (15)];
+ regs.pr_eip = *(int *) &deprecated_registers[REGISTER_BYTE (16)];
+ regs.pr_flags = *(int *) &deprecated_registers[REGISTER_BYTE (17)];
for (i = 0; i < 31; i++)
{
regs.pr_fpa.fpa_regs[i] =
- *(int *) ®isters[REGISTER_BYTE (FP1_REGNUM + i)];
+ *(int *) &deprecated_registers[REGISTER_BYTE (FP1_REGNUM + i)];
}
- memcpy (regs.pr_fpu.fpu_stack[0], ®isters[REGISTER_BYTE (ST0_REGNUM)], 10);
- memcpy (regs.pr_fpu.fpu_stack[1], ®isters[REGISTER_BYTE (ST1_REGNUM)], 10);
- memcpy (regs.pr_fpu.fpu_stack[2], ®isters[REGISTER_BYTE (ST2_REGNUM)], 10);
- memcpy (regs.pr_fpu.fpu_stack[3], ®isters[REGISTER_BYTE (ST3_REGNUM)], 10);
- memcpy (regs.pr_fpu.fpu_stack[4], ®isters[REGISTER_BYTE (ST4_REGNUM)], 10);
- memcpy (regs.pr_fpu.fpu_stack[5], ®isters[REGISTER_BYTE (ST5_REGNUM)], 10);
- memcpy (regs.pr_fpu.fpu_stack[6], ®isters[REGISTER_BYTE (ST6_REGNUM)], 10);
- memcpy (regs.pr_fpu.fpu_stack[7], ®isters[REGISTER_BYTE (ST7_REGNUM)], 10);
+ memcpy (regs.pr_fpu.fpu_stack[0], &deprecated_registers[REGISTER_BYTE (ST0_REGNUM)], 10);
+ memcpy (regs.pr_fpu.fpu_stack[1], &deprecated_registers[REGISTER_BYTE (ST1_REGNUM)], 10);
+ memcpy (regs.pr_fpu.fpu_stack[2], &deprecated_registers[REGISTER_BYTE (ST2_REGNUM)], 10);
+ memcpy (regs.pr_fpu.fpu_stack[3], &deprecated_registers[REGISTER_BYTE (ST3_REGNUM)], 10);
+ memcpy (regs.pr_fpu.fpu_stack[4], &deprecated_registers[REGISTER_BYTE (ST4_REGNUM)], 10);
+ memcpy (regs.pr_fpu.fpu_stack[5], &deprecated_registers[REGISTER_BYTE (ST5_REGNUM)], 10);
+ memcpy (regs.pr_fpu.fpu_stack[6], &deprecated_registers[REGISTER_BYTE (ST6_REGNUM)], 10);
+ memcpy (regs.pr_fpu.fpu_stack[7], &deprecated_registers[REGISTER_BYTE (ST7_REGNUM)], 10);
mptrace (XPT_WREGS, PIDGET (inferior_ptid), (PTRACE_ARG3_TYPE) & regs, 0);
}
@@ -103,29 +103,29 @@
deprecated_registers_fetched ();
mptrace (XPT_RREGS, PIDGET (inferior_ptid), (PTRACE_ARG3_TYPE) & regs, 0);
- *(int *) ®isters[REGISTER_BYTE (EAX_REGNUM)] = regs.pr_eax;
- *(int *) ®isters[REGISTER_BYTE (EBX_REGNUM)] = regs.pr_ebx;
- *(int *) ®isters[REGISTER_BYTE (ECX_REGNUM)] = regs.pr_ecx;
- *(int *) ®isters[REGISTER_BYTE (EDX_REGNUM)] = regs.pr_edx;
- *(int *) ®isters[REGISTER_BYTE (ESI_REGNUM)] = regs.pr_esi;
- *(int *) ®isters[REGISTER_BYTE (EDI_REGNUM)] = regs.pr_edi;
- *(int *) ®isters[REGISTER_BYTE (EBP_REGNUM)] = regs.pr_ebp;
- *(int *) ®isters[REGISTER_BYTE (ESP_REGNUM)] = regs.pr_esp;
- *(int *) ®isters[REGISTER_BYTE (EIP_REGNUM)] = regs.pr_eip;
- *(int *) ®isters[REGISTER_BYTE (EFLAGS_REGNUM)] = regs.pr_flags;
+ *(int *) &deprecated_registers[REGISTER_BYTE (EAX_REGNUM)] = regs.pr_eax;
+ *(int *) &deprecated_registers[REGISTER_BYTE (EBX_REGNUM)] = regs.pr_ebx;
+ *(int *) &deprecated_registers[REGISTER_BYTE (ECX_REGNUM)] = regs.pr_ecx;
+ *(int *) &deprecated_registers[REGISTER_BYTE (EDX_REGNUM)] = regs.pr_edx;
+ *(int *) &deprecated_registers[REGISTER_BYTE (ESI_REGNUM)] = regs.pr_esi;
+ *(int *) &deprecated_registers[REGISTER_BYTE (EDI_REGNUM)] = regs.pr_edi;
+ *(int *) &deprecated_registers[REGISTER_BYTE (EBP_REGNUM)] = regs.pr_ebp;
+ *(int *) &deprecated_registers[REGISTER_BYTE (ESP_REGNUM)] = regs.pr_esp;
+ *(int *) &deprecated_registers[REGISTER_BYTE (EIP_REGNUM)] = regs.pr_eip;
+ *(int *) &deprecated_registers[REGISTER_BYTE (EFLAGS_REGNUM)] = regs.pr_flags;
for (i = 0; i < FPA_NREGS; i++)
{
- *(int *) ®isters[REGISTER_BYTE (FP1_REGNUM + i)] =
+ *(int *) &deprecated_registers[REGISTER_BYTE (FP1_REGNUM + i)] =
regs.pr_fpa.fpa_regs[i];
}
- memcpy (®isters[REGISTER_BYTE (ST0_REGNUM)], regs.pr_fpu.fpu_stack[0], 10);
- memcpy (®isters[REGISTER_BYTE (ST1_REGNUM)], regs.pr_fpu.fpu_stack[1], 10);
- memcpy (®isters[REGISTER_BYTE (ST2_REGNUM)], regs.pr_fpu.fpu_stack[2], 10);
- memcpy (®isters[REGISTER_BYTE (ST3_REGNUM)], regs.pr_fpu.fpu_stack[3], 10);
- memcpy (®isters[REGISTER_BYTE (ST4_REGNUM)], regs.pr_fpu.fpu_stack[4], 10);
- memcpy (®isters[REGISTER_BYTE (ST5_REGNUM)], regs.pr_fpu.fpu_stack[5], 10);
- memcpy (®isters[REGISTER_BYTE (ST6_REGNUM)], regs.pr_fpu.fpu_stack[6], 10);
- memcpy (®isters[REGISTER_BYTE (ST7_REGNUM)], regs.pr_fpu.fpu_stack[7], 10);
+ memcpy (&deprecated_registers[REGISTER_BYTE (ST0_REGNUM)], regs.pr_fpu.fpu_stack[0], 10);
+ memcpy (&deprecated_registers[REGISTER_BYTE (ST1_REGNUM)], regs.pr_fpu.fpu_stack[1], 10);
+ memcpy (&deprecated_registers[REGISTER_BYTE (ST2_REGNUM)], regs.pr_fpu.fpu_stack[2], 10);
+ memcpy (&deprecated_registers[REGISTER_BYTE (ST3_REGNUM)], regs.pr_fpu.fpu_stack[3], 10);
+ memcpy (&deprecated_registers[REGISTER_BYTE (ST4_REGNUM)], regs.pr_fpu.fpu_stack[4], 10);
+ memcpy (&deprecated_registers[REGISTER_BYTE (ST5_REGNUM)], regs.pr_fpu.fpu_stack[5], 10);
+ memcpy (&deprecated_registers[REGISTER_BYTE (ST6_REGNUM)], regs.pr_fpu.fpu_stack[6], 10);
+ memcpy (&deprecated_registers[REGISTER_BYTE (ST7_REGNUM)], regs.pr_fpu.fpu_stack[7], 10);
}
/* FIXME: This should be merged with i387-tdep.c as well. */
Index: v850ice.c
===================================================================
RCS file: /cvs/src/src/gdb/v850ice.c,v
retrieving revision 1.12
diff -u -r1.12 v850ice.c
--- v850ice.c 2 Oct 2002 21:33:58 -0000 1.12
+++ v850ice.c 7 Nov 2002 22:45:44 -0000
@@ -560,7 +560,7 @@
return;
}
- regval = extract_unsigned_integer (®isters[REGISTER_BYTE (regno)],
+ regval = extract_unsigned_integer (&deprecated_registers[REGISTER_BYTE (regno)],
REGISTER_RAW_SIZE (regno));
strcpy (cmd, "reg ");
if (!convert_register (regno, &cmd[4]))