darkkirb/old-cross-binutils
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

2002-11-14 Andrew Cagney <ac131313@redhat.com>

Browse source 
* regcache.h (deprecated_registers): Rename registers.
	* a68v-nat.c, alpha-nat.c, arch-utils.c, core-sol2.c: Update.
	* hp300ux-nat.c, hppab-nat.c, hppah-nat.c: Update.
	* hppam3-nat.c, hpux-thread.c, i386gnu-nat.c: Update.
	* ia64-aix-nat.c, ia64-linux-nat.c, ia64-tdep.c: Update.
	* irix4-nat.c, irix5-nat.c, lynx-nat.c, m68k-tdep.c: Update.
	* m68knbsd-nat.c, mips-linux-tdep.c, mipsm3-nat.c: Update.
	* mipsv4-nat.c, ns32knbsd-nat.c, ppc-bdm.c: Update.
	* ppc-sysv-tdep.c, ptx4-nat.c, regcache.c, remote-es.c: Update.
	* remote-sds.c, remote-vx68.c, remote-vxmips.c: Update.
	* remote-vxsparc.c, rs6000-tdep.c, sol-thread.c: Update.
	* sparc-nat.c, sparc-tdep.c, sun3-nat.c, symm-nat.c: Update.
	* v850ice.c: Update.
This commit is contained in:
Andrew Cagney 2002-11-14 20:37:29 +00:00
parent 2fa9fc65a5
commit 524d7c188c
40 changed files with 347 additions and 292 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
gdb/ChangeLog
View file

@ -1,3 +1,19 @@
2002-11-14 Andrew Cagney <ac131313@redhat.com>
* regcache.h (deprecated_registers): Rename registers.
* a68v-nat.c, alpha-nat.c, arch-utils.c, core-sol2.c: Update.
* hp300ux-nat.c, hppab-nat.c, hppah-nat.c: Update.
* hppam3-nat.c, hpux-thread.c, i386gnu-nat.c: Update.
* ia64-aix-nat.c, ia64-linux-nat.c, ia64-tdep.c: Update.
* irix4-nat.c, irix5-nat.c, lynx-nat.c, m68k-tdep.c: Update.
* m68knbsd-nat.c, mips-linux-tdep.c, mipsm3-nat.c: Update.
* mipsv4-nat.c, ns32knbsd-nat.c, ppc-bdm.c: Update.
* ppc-sysv-tdep.c, ptx4-nat.c, regcache.c, remote-es.c: Update.
* remote-sds.c, remote-vx68.c, remote-vxmips.c: Update.
* remote-vxsparc.c, rs6000-tdep.c, sol-thread.c: Update.
* sparc-nat.c, sparc-tdep.c, sun3-nat.c, symm-nat.c: Update.
* v850ice.c: Update.
Wed Nov 13 19:51:05 2002 Andrew Cagney <cagney@redhat.com> Wed Nov 13 19:51:05 2002 Andrew Cagney <cagney@redhat.com>
* utils.c (gdb_realpath): Add comment mentioning realpath with a * utils.c (gdb_realpath): Add comment mentioning realpath with a

24
gdb/a68v-nat.c
View file

@ -61,11 +61,14 @@ fetch_inferior_registers (int ignored)
(PTRACE_ARG3_TYPE) & inferior_control_registers, (PTRACE_ARG3_TYPE) & inferior_control_registers,
ptrace_$control_set_m68k); ptrace_$control_set_m68k);
bcopy (&inferior_registers, registers, 16 * 4); bcopy (&inferior_registers, &deprecated_registers[0], 16 * 4);
bcopy (&inferior_fp_registers, &registers[REGISTER_BYTE (FP0_REGNUM)], bcopy (&inferior_fp_registers,
&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
sizeof inferior_fp_registers.regs); sizeof inferior_fp_registers.regs);
*(int *) &registers[REGISTER_BYTE (PS_REGNUM)] = inferior_control_registers.sr; *(int *) &deprecated_registers[REGISTER_BYTE (PS_REGNUM)]
*(int *) &registers[REGISTER_BYTE (PC_REGNUM)] = inferior_control_registers.pc; = inferior_control_registers.sr;
*(int *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)]
= inferior_control_registers.pc;
} }
/* Store our register values back into the inferior. /* Store our register values back into the inferior.
@ -94,13 +97,16 @@ store_inferior_registers (int regno)
(PTRACE_ARG3_TYPE) & inferior_control_registers, (PTRACE_ARG3_TYPE) & inferior_control_registers,
ptrace_$control_set_m68k); ptrace_$control_set_m68k);
bcopy (registers, &inferior_registers, sizeof (inferior_registers)); bcopy (&deprecated_registers[0], &inferior_registers,
sizeof (inferior_registers));
bcopy (&registers[REGISTER_BYTE (FP0_REGNUM)], inferior_fp_registers.regs, bcopy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
sizeof inferior_fp_registers.regs); inferior_fp_registers.regs, sizeof inferior_fp_registers.regs);
inferior_control_registers.sr = *(int *) &registers[REGISTER_BYTE (PS_REGNUM)]; inferior_control_registers.sr
inferior_control_registers.pc = *(int *) &registers[REGISTER_BYTE (PC_REGNUM)]; = *(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 (PTRACE_SETREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_registers, (PTRACE_ARG3_TYPE) & inferior_registers,

20
gdb/alpha-nat.c
View file

@ -133,17 +133,19 @@ fetch_elf_core_registers (char *core_reg_sect, unsigned core_reg_size,
if (which == 2) if (which == 2)
{ {
/* The FPU Registers. */ /* The FPU Registers. */
memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)], core_reg_sect, 31 * 8); memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
memset (&registers[REGISTER_BYTE (FP0_REGNUM + 31)], 0, 8); core_reg_sect, 31 * 8);
memset (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM + 31)], 0, 8);
memset (&deprecated_register_valid[FP0_REGNUM], 1, 32); memset (&deprecated_register_valid[FP0_REGNUM], 1, 32);
} }
else else
{ {
/* The General Registers. */ /* The General Registers. */
memcpy (&registers[REGISTER_BYTE (ALPHA_V0_REGNUM)], core_reg_sect, memcpy (&deprecated_registers[REGISTER_BYTE (ALPHA_V0_REGNUM)],
31 * 8); core_reg_sect, 31 * 8);
memcpy (&registers[REGISTER_BYTE (PC_REGNUM)], core_reg_sect + 31 * 8, 8); memcpy (&deprecated_registers[REGISTER_BYTE (PC_REGNUM)],
memset (&registers[REGISTER_BYTE (ALPHA_ZERO_REGNUM)], 0, 8); 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); memset (&deprecated_register_valid[ALPHA_V0_REGNUM], 1, 32);
deprecated_register_valid[PC_REGNUM] = 1; deprecated_register_valid[PC_REGNUM] = 1;
} }
@ -209,10 +211,10 @@ fill_gregset (gdb_gregset_t *gregsetp, int regno)
for (regi = 0; regi < 31; regi++) for (regi = 0; regi < 31; regi++)
if ((regno == -1) || (regno == regi)) if ((regno == -1) || (regno == regi))
*(regp + regi) = *(long *) &registers[REGISTER_BYTE (regi)]; *(regp + regi) = *(long *) &deprecated_registers[REGISTER_BYTE (regi)];
if ((regno == -1) || (regno == PC_REGNUM)) if ((regno == -1) || (regno == PC_REGNUM))
*(regp + 31) = *(long *) &registers[REGISTER_BYTE (PC_REGNUM)]; *(regp + 31) = *(long *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)];
} }
/* /*
@ -241,7 +243,7 @@ fill_fpregset (gdb_fpregset_t *fpregsetp, int regno)
if ((regno == -1) || (regno == regi)) if ((regno == -1) || (regno == regi))
{ {
*(regp + regi - FP0_REGNUM) = *(regp + regi - FP0_REGNUM) =
*(long *) &registers[REGISTER_BYTE (regi)]; *(long *) &deprecated_registers[REGISTER_BYTE (regi)];
} }
} }
} }

2
gdb/arch-utils.c
View file

@ -99,7 +99,7 @@ legacy_extract_return_value (struct type *type, struct regcache *regcache,
{ {
char *registers = deprecated_grub_regcache_for_registers (regcache); char *registers = deprecated_grub_regcache_for_registers (regcache);
bfd_byte *buf = valbuf; bfd_byte *buf = valbuf;
DEPRECATED_EXTRACT_RETURN_VALUE (type, registers, buf); DEPRECATED_EXTRACT_RETURN_VALUE (type, registers, buf); /* OK */
} }
/* Implementation of store return value that grubs the register cache. /* Implementation of store return value that grubs the register cache.

30
gdb/core-sol2.c
View file

@ -94,15 +94,19 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which,
struct regs *gregs = (struct regs *) core_reg_sect; struct regs *gregs = (struct regs *) core_reg_sect;
/* G0 *always* holds 0. */ /* G0 *always* holds 0. */
*(int *) &registers[REGISTER_BYTE (0)] = 0; *(int *) &deprecated_registers[REGISTER_BYTE (0)] = 0;
/* The globals and output registers. */ /* The globals and output registers. */
memcpy (&registers[REGISTER_BYTE (G1_REGNUM)], &gregs->r_g1, memcpy (&deprecated_registers[REGISTER_BYTE (G1_REGNUM)],
15 * REGISTER_RAW_SIZE (G1_REGNUM)); &gregs->r_g1, 15 * REGISTER_RAW_SIZE (G1_REGNUM));
*(int *) &registers[REGISTER_BYTE (PS_REGNUM)] = gregs->r_ps; *(int *) &deprecated_registers[REGISTER_BYTE (PS_REGNUM)]
*(int *) &registers[REGISTER_BYTE (PC_REGNUM)] = gregs->r_pc; = gregs->r_ps;
*(int *) &registers[REGISTER_BYTE (NPC_REGNUM)] = gregs->r_npc; *(int *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)]
*(int *) &registers[REGISTER_BYTE (Y_REGNUM)] = gregs->r_y; = 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 /* My best guess at where to get the locals and input
registers is exactly where they usually are, right above registers is exactly where they usually are, right above
@ -112,9 +116,9 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which,
{ {
int sp; int sp;
sp = *(int *) &registers[REGISTER_BYTE (SP_REGNUM)]; sp = *(int *) &deprecated_registers[REGISTER_BYTE (SP_REGNUM)];
if (0 != target_read_memory (sp, if (0 != target_read_memory (sp,
&registers[REGISTER_BYTE (L0_REGNUM)], &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
16 * REGISTER_RAW_SIZE (L0_REGNUM))) 16 * 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");
@ -163,10 +167,10 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which,
{ {
struct fpu *fpuregs = (struct fpu *) core_reg_sect; struct fpu *fpuregs = (struct fpu *) core_reg_sect;
memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)], &fpuregs->fpu_fr, memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
sizeof (fpuregs->fpu_fr)); &fpuregs->fpu_fr, sizeof (fpuregs->fpu_fr));
memcpy (&registers[REGISTER_BYTE (FPS_REGNUM)], &fpuregs->fpu_fsr, memcpy (&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)],
sizeof (FPU_FSR_TYPE)); &fpuregs->fpu_fsr, sizeof (FPU_FSR_TYPE));
} }
else else
{ {

2
gdb/hp300ux-nat.c
View file

@ -161,7 +161,7 @@ store_inferior_register (register int regno, register unsigned int regaddr)
{ {
store_inferior_register_1 store_inferior_register_1
(regno, regaddr, (regno, regaddr,
(*(int *) &registers[(REGISTER_BYTE (regno)) + i])); (*(int *) &deprecated_registers[(REGISTER_BYTE (regno)) + i]));
regaddr += sizeof (int); regaddr += sizeof (int);
} }
} }

4
gdb/hppab-nat.c
View file

@ -118,7 +118,7 @@ store_inferior_registers (int regno)
errno = 0; errno = 0;
if (regno == PCOQ_HEAD_REGNUM || regno == PCOQ_TAIL_REGNUM) if (regno == PCOQ_HEAD_REGNUM || regno == PCOQ_TAIL_REGNUM)
{ {
scratch = *(int *) &registers[REGISTER_BYTE (regno)] | 0x3; scratch = *(int *) &deprecated_registers[REGISTER_BYTE (regno)] | 0x3;
ptrace (PT_WUREGS, PIDGET (inferior_ptid), (PTRACE_ARG3_TYPE) regaddr, ptrace (PT_WUREGS, PIDGET (inferior_ptid), (PTRACE_ARG3_TYPE) regaddr,
scratch); scratch);
if (errno != 0) if (errno != 0)
@ -135,7 +135,7 @@ store_inferior_registers (int regno)
errno = 0; errno = 0;
ptrace (PT_WUREGS, PIDGET (inferior_ptid), ptrace (PT_WUREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) regaddr, (PTRACE_ARG3_TYPE) regaddr,
*(int *) &registers[REGISTER_BYTE (regno) + i]); *(int *) &deprecated_registers[REGISTER_BYTE (regno) + i]);
if (errno != 0) if (errno != 0)
{ {
/* Warning, not error, in case we are attached; sometimes the /* Warning, not error, in case we are attached; sometimes the

6
gdb/hppah-nat.c
View file

@ -121,7 +121,7 @@ store_inferior_registers (int regno)
{ {
CORE_ADDR temp; CORE_ADDR temp;
temp = *(CORE_ADDR *)&registers[REGISTER_BYTE (regno)]; temp = *(CORE_ADDR *)&deprecated_registers[REGISTER_BYTE (regno)];
/* Set the priv level (stored in the low two bits of the PC. */ /* Set the priv level (stored in the low two bits of the PC. */
temp |= 0x3; temp |= 0x3;
@ -146,7 +146,7 @@ store_inferior_registers (int regno)
the high part of IPSW. What will it take for HP to catch a the high part of IPSW. What will it take for HP to catch a
clue about building sensible interfaces? */ clue about building sensible interfaces? */
if (regno == IPSW_REGNUM && len == 8) if (regno == IPSW_REGNUM && len == 8)
*(int *)&registers[REGISTER_BYTE (regno)] = 0; *(int *)&deprecated_registers[REGISTER_BYTE (regno)] = 0;
#endif #endif
for (i = 0; i < len; i += sizeof (int)) for (i = 0; i < len; i += sizeof (int))
@ -154,7 +154,7 @@ store_inferior_registers (int regno)
errno = 0; errno = 0;
call_ptrace (PT_WUREGS, PIDGET (inferior_ptid), call_ptrace (PT_WUREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) addr + i, (PTRACE_ARG3_TYPE) addr + i,
*(int *) &registers[REGISTER_BYTE (regno) + i]); *(int *) &deprecated_registers[REGISTER_BYTE (regno) + i]);
if (errno != 0) if (errno != 0)
{ {
/* Warning, not error, in case we are attached; sometimes /* Warning, not error, in case we are attached; sometimes

6
gdb/hppam3-nat.c
View file

@ -113,15 +113,15 @@ store_inferior_registers (int regno)
*/ */
if (regno > 0 && regno < NUM_REGS) if (regno > 0 && regno < NUM_REGS)
{ {
memcpy (&state[regno], &registers[REGISTER_BYTE (regno)], memcpy (&state[regno], &deprecated_registers[REGISTER_BYTE (regno)],
REGISTER_RAW_SIZE (regno)); REGISTER_RAW_SIZE (regno));
} }
else else
{ {
for (index = 0; index < NUM_REGS; index++) for (index = 0; index < NUM_REGS; index++)
memcpy (&state[index], &registers[REGISTER_BYTE (index)], memcpy (&state[index], &deprecated_registers[REGISTER_BYTE (index)],
REGISTER_RAW_SIZE (index)); REGISTER_RAW_SIZE (index));
/* state[index] = registers[REGISTER_BYTE (index)]; */ /* state[index] = deprecated_registers[REGISTER_BYTE (index)]; */
} }

9
gdb/hpux-thread.c
View file

@ -357,18 +357,19 @@ hpux_thread_store_registers (int regno)
else if (regno == SP_REGNUM) else if (regno == SP_REGNUM)
{ {
write_memory ((CORE_ADDR) & tcb_ptr->static_ctx.sp, write_memory ((CORE_ADDR) & tcb_ptr->static_ctx.sp,
registers + REGISTER_BYTE (regno), &deprecated_registers[REGISTER_BYTE (regno)],
REGISTER_RAW_SIZE (regno)); REGISTER_RAW_SIZE (regno));
tcb_ptr->static_ctx.sp = (cma__t_hppa_regs *) 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) else if (regno == PC_REGNUM)
write_memory (sp - 20, write_memory (sp - 20,
registers + REGISTER_BYTE (regno), &deprecated_registers[REGISTER_BYTE (regno)],
REGISTER_RAW_SIZE (regno)); REGISTER_RAW_SIZE (regno));
else else
write_memory (sp + regmap[regno], write_memory (sp + regmap[regno],
registers + REGISTER_BYTE (regno), &deprecated_registers[REGISTER_BYTE (regno)],
REGISTER_RAW_SIZE (regno)); REGISTER_RAW_SIZE (regno));
} }
} }

2
gdb/i386gnu-nat.c
View file

@ -256,7 +256,7 @@ gnu_store_registers (int regno)
} }
#define fill(state, regno) \ #define fill(state, regno) \
memcpy (REG_ADDR(state, regno), &registers[REGISTER_BYTE (regno)], \ memcpy (REG_ADDR(state, regno), &deprecated_registers[REGISTER_BYTE (regno)], \
REGISTER_RAW_SIZE (regno)) REGISTER_RAW_SIZE (regno))
if (regno == -1) if (regno == -1)

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

@ -85,7 +85,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_), &registers[REGISTER_BYTE (_regi_)], \ memcpy (&(gregsetp->_fld_), &deprecated_registers[REGISTER_BYTE (_regi_)], \
REGISTER_RAW_SIZE (_regi_)) REGISTER_RAW_SIZE (_regi_))
for (regi = IA64_GR0_REGNUM; regi <= IA64_GR31_REGNUM; regi++) for (regi = IA64_GR0_REGNUM; regi <= IA64_GR31_REGNUM; regi++)
@ -108,10 +108,10 @@ fill_gregset (prgregset_t *gregsetp, int regno)
if (regno == IA64_BSP_REGNUM || regno == -1) if (regno == IA64_BSP_REGNUM || regno == -1)
{ {
memcpy (&(gregsetp->__bspstore), memcpy (&(gregsetp->__bspstore),
&registers[REGISTER_BYTE (IA64_BSP_REGNUM)], &deprecated_registers[REGISTER_BYTE (IA64_BSP_REGNUM)],
REGISTER_RAW_SIZE (IA64_BSP_REGNUM)); REGISTER_RAW_SIZE (IA64_BSP_REGNUM));
memcpy (&registers[REGISTER_BYTE (IA64_BSPSTORE_REGNUM)], memcpy (&deprecated_registers[REGISTER_BYTE (IA64_BSPSTORE_REGNUM)],
&registers[REGISTER_BYTE (IA64_BSP_REGNUM)], &deprecated_registers[REGISTER_BYTE (IA64_BSP_REGNUM)],
REGISTER_RAW_SIZE (IA64_BSP_REGNUM)); REGISTER_RAW_SIZE (IA64_BSP_REGNUM));
} }
@ -153,7 +153,7 @@ fill_fpregset (prfpregset_t *fpregsetp, int regno)
{ {
if ((regno == -1) || (regno == regi)) if ((regno == -1) || (regno == regi))
{ {
from = (char *) &registers[REGISTER_BYTE (regi)]; from = (char *) &deprecated_registers[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, REGISTER_RAW_SIZE (regi));
} }

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

@ -400,7 +400,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_, &registers[REGISTER_BYTE (_regi_)], \ memcpy (regp + _idx_, &deprecated_registers[REGISTER_BYTE (_regi_)], \
REGISTER_RAW_SIZE (_regi_)) REGISTER_RAW_SIZE (_regi_))
for (regi = IA64_GR0_REGNUM; regi <= IA64_GR31_REGNUM; regi++) for (regi = IA64_GR0_REGNUM; regi <= IA64_GR31_REGNUM; regi++)
@ -465,7 +465,7 @@ fill_fpregset (fpregset_t *fpregsetp, int regno)
{ {
if ((regno == -1) || (regno == regi)) if ((regno == -1) || (regno == regi))
{ {
from = (char *) &registers[REGISTER_BYTE (regi)]; from = (char *) &deprecated_registers[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, REGISTER_RAW_SIZE (regi));
} }

6
gdb/ia64-tdep.c
View file

@ -1902,7 +1902,7 @@ ia64_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
float_elt_type, float_elt_type,
floatreg, floatreg,
VALUE_CONTENTS (arg) + argoffset, VALUE_CONTENTS (arg) + argoffset,
&registers[REGISTER_BYTE (floatreg)]); &deprecated_registers[REGISTER_BYTE (floatreg)]);
floatreg++; floatreg++;
argoffset += TYPE_LENGTH (float_elt_type); argoffset += TYPE_LENGTH (float_elt_type);
len -= TYPE_LENGTH (float_elt_type); len -= TYPE_LENGTH (float_elt_type);
@ -1913,7 +1913,7 @@ ia64_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
/* Store the struct return value in r8 if necessary. */ /* Store the struct return value in r8 if necessary. */
if (struct_return) if (struct_return)
{ {
store_address (&registers[REGISTER_BYTE (IA64_GR8_REGNUM)], store_address (&deprecated_registers[REGISTER_BYTE (IA64_GR8_REGNUM)],
REGISTER_RAW_SIZE (IA64_GR8_REGNUM), REGISTER_RAW_SIZE (IA64_GR8_REGNUM),
struct_addr); struct_addr);
} }
@ -1954,7 +1954,7 @@ ia64_store_return_value (struct type *type, char *valbuf)
if (TYPE_CODE (type) == TYPE_CODE_FLT) if (TYPE_CODE (type) == TYPE_CODE_FLT)
{ {
ia64_register_convert_to_raw (type, IA64_FR8_REGNUM, valbuf, ia64_register_convert_to_raw (type, IA64_FR8_REGNUM, valbuf,
&registers[REGISTER_BYTE (IA64_FR8_REGNUM)]); &deprecated_registers[REGISTER_BYTE (IA64_FR8_REGNUM)]);
target_store_registers (IA64_FR8_REGNUM); target_store_registers (IA64_FR8_REGNUM);
} }
else else

16
gdb/irix4-nat.c
View file

@ -77,19 +77,19 @@ fill_gregset (gregset_t *gregsetp, int regno)
/* same FIXME as above wrt 32 */ /* same FIXME as above wrt 32 */
for (regi = 0; regi < 32; regi++) for (regi = 0; regi < 32; regi++)
if ((regno == -1) || (regno == 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)) 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)) 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)) 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)) 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 @@ fill_fpregset (fpregset_t *fpregsetp, int regno)
{ {
if ((regno == -1) || (regno == regi)) if ((regno == -1) || (regno == regi))
{ {
from = (char *) &registers[REGISTER_BYTE (regi)]; from = (char *) &deprecated_registers[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, REGISTER_RAW_SIZE (regi));
} }
} }
if ((regno == -1) || (regno == FCRCS_REGNUM)) if ((regno == -1) || (regno == FCRCS_REGNUM))
fpregsetp->fp_csr = *(unsigned *) &registers[REGISTER_BYTE (FCRCS_REGNUM)]; fpregsetp->fp_csr = *(unsigned *) &deprecated_registers[REGISTER_BYTE (FCRCS_REGNUM)];
} }
@ -184,7 +184,7 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
return; return;
} }
memcpy ((char *) registers, core_reg_sect, core_reg_size); memcpy ((char *) deprecated_registers, core_reg_sect, core_reg_size);
} }

18
gdb/irix5-nat.c
View file

@ -83,27 +83,27 @@ fill_gregset (gregset_t *gregsetp, int regno)
for (regi = 0; regi <= CTX_RA; regi++) for (regi = 0; regi <= CTX_RA; regi++)
if ((regno == -1) || (regno == regi)) if ((regno == -1) || (regno == regi))
*(regp + regi) = *(regp + regi) =
extract_signed_integer (&registers[REGISTER_BYTE (regi)], extract_signed_integer (&deprecated_registers[REGISTER_BYTE (regi)],
REGISTER_RAW_SIZE (regi)); 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 (&registers[REGISTER_BYTE (PC_REGNUM)], extract_signed_integer (&deprecated_registers[REGISTER_BYTE (PC_REGNUM)],
REGISTER_RAW_SIZE (PC_REGNUM)); 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 (&registers[REGISTER_BYTE (CAUSE_REGNUM)], extract_signed_integer (&deprecated_registers[REGISTER_BYTE (CAUSE_REGNUM)],
REGISTER_RAW_SIZE (CAUSE_REGNUM)); 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 (&registers[REGISTER_BYTE (HI_REGNUM)], extract_signed_integer (&deprecated_registers[REGISTER_BYTE (HI_REGNUM)],
REGISTER_RAW_SIZE (HI_REGNUM)); 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 (&registers[REGISTER_BYTE (LO_REGNUM)], extract_signed_integer (&deprecated_registers[REGISTER_BYTE (LO_REGNUM)],
REGISTER_RAW_SIZE (LO_REGNUM)); REGISTER_RAW_SIZE (LO_REGNUM));
} }
@ -145,14 +145,14 @@ fill_fpregset (fpregset_t *fpregsetp, int regno)
{ {
if ((regno == -1) || (regno == regi)) if ((regno == -1) || (regno == regi))
{ {
from = (char *) &registers[REGISTER_BYTE (regi)]; from = (char *) &deprecated_registers[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, REGISTER_RAW_SIZE (regi));
} }
} }
if ((regno == -1) || (regno == FCRCS_REGNUM)) if ((regno == -1) || (regno == FCRCS_REGNUM))
fpregsetp->fp_csr = *(unsigned *) &registers[REGISTER_BYTE (FCRCS_REGNUM)]; fpregsetp->fp_csr = *(unsigned *) &deprecated_registers[REGISTER_BYTE (FCRCS_REGNUM)];
} }
@ -198,7 +198,7 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
{ {
if (core_reg_size == REGISTER_BYTES) 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 && else if (MIPS_REGSIZE == 4 &&
core_reg_size == (2 * MIPS_REGSIZE) * NUM_REGS) core_reg_size == (2 * MIPS_REGSIZE) * NUM_REGS)
@ -206,7 +206,7 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
/* This is a core file from a N32 executable, 64 bits are saved /* This is a core file from a N32 executable, 64 bits are saved
for all registers. */ for all registers. */
char *srcp = core_reg_sect; char *srcp = core_reg_sect;
char *dstp = registers; char *dstp = deprecated_registers;
int regno; int regno;
for (regno = 0; regno < NUM_REGS; regno++) for (regno = 0; regno < NUM_REGS; regno++)

24
gdb/lynx-nat.c
View file

@ -296,7 +296,7 @@ fetch_inferior_registers (int regno)
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 (&registers[REGISTER_BYTE (G1_REGNUM)], &ec.g1, memcpy (&deprecated_registers[REGISTER_BYTE (G1_REGNUM)], &ec.g1,
4 * REGISTER_RAW_SIZE (G1_REGNUM)); 4 * 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;
@ -307,7 +307,7 @@ fetch_inferior_registers (int regno)
supply_register (NPC_REGNUM, (char *) &ec.npc); supply_register (NPC_REGNUM, (char *) &ec.npc);
supply_register (WIM_REGNUM, (char *) &ec.wim); supply_register (WIM_REGNUM, (char *) &ec.wim);
memcpy (&registers[REGISTER_BYTE (O0_REGNUM)], ec.o, memcpy (&deprecated_registers[REGISTER_BYTE (O0_REGNUM)], ec.o,
8 * REGISTER_RAW_SIZE (O0_REGNUM)); 8 * 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;
@ -321,13 +321,13 @@ fetch_inferior_registers (int regno)
sp = read_register (SP_REGNUM); sp = read_register (SP_REGNUM);
target_read_memory (sp + FRAME_SAVED_I0, target_read_memory (sp + FRAME_SAVED_I0,
&registers[REGISTER_BYTE (I0_REGNUM)], &deprecated_registers[REGISTER_BYTE (I0_REGNUM)],
8 * REGISTER_RAW_SIZE (I0_REGNUM)); 8 * 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,
&registers[REGISTER_BYTE (L0_REGNUM)], &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
8 * REGISTER_RAW_SIZE (L0_REGNUM)); 8 * 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;
@ -345,7 +345,7 @@ fetch_inferior_registers (int regno)
if (errno) if (errno)
perror_with_name ("ptrace(PTRACE_GETFPREGS)"); perror_with_name ("ptrace(PTRACE_GETFPREGS)");
memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)], fc.f.fregs, memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)], fc.f.fregs,
32 * REGISTER_RAW_SIZE (FP0_REGNUM)); 32 * 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;
@ -383,7 +383,7 @@ store_inferior_registers (int regno)
int retval; int retval;
ec.tbr = read_register (TBR_REGNUM); ec.tbr = read_register (TBR_REGNUM);
memcpy (&ec.g1, &registers[REGISTER_BYTE (G1_REGNUM)], memcpy (&ec.g1, &deprecated_registers[REGISTER_BYTE (G1_REGNUM)],
4 * REGISTER_RAW_SIZE (G1_REGNUM)); 4 * REGISTER_RAW_SIZE (G1_REGNUM));
ec.psr = read_register (PS_REGNUM); ec.psr = read_register (PS_REGNUM);
@ -392,7 +392,7 @@ store_inferior_registers (int regno)
ec.npc = read_register (NPC_REGNUM); ec.npc = read_register (NPC_REGNUM);
ec.wim = read_register (WIM_REGNUM); ec.wim = read_register (WIM_REGNUM);
memcpy (ec.o, &registers[REGISTER_BYTE (O0_REGNUM)], memcpy (ec.o, &deprecated_registers[REGISTER_BYTE (O0_REGNUM)],
8 * REGISTER_RAW_SIZE (O0_REGNUM)); 8 * REGISTER_RAW_SIZE (O0_REGNUM));
errno = 0; errno = 0;
@ -414,11 +414,11 @@ store_inferior_registers (int regno)
if (!deprecated_register_valid[L0_REGNUM + 5]) if (!deprecated_register_valid[L0_REGNUM + 5])
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,
&registers[REGISTER_BYTE (I0_REGNUM)], &deprecated_registers[REGISTER_BYTE (I0_REGNUM)],
8 * REGISTER_RAW_SIZE (I0_REGNUM)); 8 * REGISTER_RAW_SIZE (I0_REGNUM));
target_write_memory (sp + FRAME_SAVED_L0, target_write_memory (sp + FRAME_SAVED_L0,
&registers[REGISTER_BYTE (L0_REGNUM)], &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
8 * REGISTER_RAW_SIZE (L0_REGNUM)); 8 * REGISTER_RAW_SIZE (L0_REGNUM));
} }
else if (regno >= L0_REGNUM && regno <= I7_REGNUM) else if (regno >= L0_REGNUM && regno <= I7_REGNUM)
@ -432,7 +432,7 @@ store_inferior_registers (int regno)
regoffset = REGISTER_BYTE (regno) - REGISTER_BYTE (I0_REGNUM) regoffset = REGISTER_BYTE (regno) - REGISTER_BYTE (I0_REGNUM)
+ FRAME_SAVED_I0; + FRAME_SAVED_I0;
target_write_memory (sp + regoffset, target_write_memory (sp + regoffset,
&registers[REGISTER_BYTE (regno)], &deprecated_registers[REGISTER_BYTE (regno)],
REGISTER_RAW_SIZE (regno)); REGISTER_RAW_SIZE (regno));
} }
} }
@ -449,7 +449,7 @@ store_inferior_registers (int regno)
if (errno) if (errno)
perror_with_name ("ptrace(PTRACE_GETFPREGS)"); perror_with_name ("ptrace(PTRACE_GETFPREGS)");
memcpy (fc.f.fregs, &registers[REGISTER_BYTE (FP0_REGNUM)], memcpy (fc.f.fregs, &deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
32 * REGISTER_RAW_SIZE (FP0_REGNUM)); 32 * REGISTER_RAW_SIZE (FP0_REGNUM));
fc.fsr = read_register (FPS_REGNUM); fc.fsr = read_register (FPS_REGNUM);
@ -571,7 +571,7 @@ store_inferior_registers (int regno)
{ {
unsigned int reg; unsigned int reg;
reg = *(unsigned int *) &registers[REGISTER_BYTE (regno) + i]; reg = *(unsigned int *) &deprecated_registers[REGISTER_BYTE (regno) + i];
errno = 0; errno = 0;
ptrace (ptrace_fun, PIDGET (inferior_ptid), ptrace (ptrace_fun, PIDGET (inferior_ptid),

14
gdb/m68k-tdep.c
View file

@ -837,16 +837,16 @@ fill_gregset (gregset_t *gregsetp, int regno)
{ {
if ((regno == -1) || (regno == regi)) if ((regno == -1) || (regno == regi))
{ {
*(regp + regi) = *(int *) &registers[REGISTER_BYTE (regi)]; *(regp + regi) = *(int *) &deprecated_registers[REGISTER_BYTE (regi)];
} }
} }
if ((regno == -1) || (regno == PS_REGNUM)) if ((regno == -1) || (regno == PS_REGNUM))
{ {
*(regp + R_PS) = *(int *) &registers[REGISTER_BYTE (PS_REGNUM)]; *(regp + R_PS) = *(int *) &deprecated_registers[REGISTER_BYTE (PS_REGNUM)];
} }
if ((regno == -1) || (regno == PC_REGNUM)) if ((regno == -1) || (regno == PC_REGNUM))
{ {
*(regp + R_PC) = *(int *) &registers[REGISTER_BYTE (PC_REGNUM)]; *(regp + R_PC) = *(int *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)];
} }
} }
@ -888,22 +888,22 @@ fill_fpregset (fpregset_t *fpregsetp, int regno)
{ {
if ((regno == -1) || (regno == regi)) if ((regno == -1) || (regno == regi))
{ {
from = (char *) &registers[REGISTER_BYTE (regi)]; from = (char *) &deprecated_registers[REGISTER_BYTE (regi)];
to = (char *) &(fpregsetp->f_fpregs[regi - FP0_REGNUM][0]); to = (char *) &(fpregsetp->f_fpregs[regi - FP0_REGNUM][0]);
memcpy (to, from, REGISTER_RAW_SIZE (regi)); memcpy (to, from, REGISTER_RAW_SIZE (regi));
} }
} }
if ((regno == -1) || (regno == E_FPC_REGNUM)) if ((regno == -1) || (regno == E_FPC_REGNUM))
{ {
fpregsetp->f_pcr = *(int *) &registers[REGISTER_BYTE (E_FPC_REGNUM)]; fpregsetp->f_pcr = *(int *) &deprecated_registers[REGISTER_BYTE (E_FPC_REGNUM)];
} }
if ((regno == -1) || (regno == E_FPS_REGNUM)) if ((regno == -1) || (regno == E_FPS_REGNUM))
{ {
fpregsetp->f_psr = *(int *) &registers[REGISTER_BYTE (E_FPS_REGNUM)]; fpregsetp->f_psr = *(int *) &deprecated_registers[REGISTER_BYTE (E_FPS_REGNUM)];
} }
if ((regno == -1) || (regno == E_FPI_REGNUM)) if ((regno == -1) || (regno == E_FPI_REGNUM))
{ {
fpregsetp->f_fpiaddr = *(int *) &registers[REGISTER_BYTE (E_FPI_REGNUM)]; fpregsetp->f_fpiaddr = *(int *) &deprecated_registers[REGISTER_BYTE (E_FPI_REGNUM)];
} }
} }

12
gdb/m68knbsd-nat.c
View file

@ -36,12 +36,12 @@ fetch_inferior_registers (int regno)
ptrace (PT_GETREGS, PIDGET (inferior_ptid), ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_registers, 0); (PTRACE_ARG3_TYPE) & inferior_registers, 0);
memcpy (&registers[REGISTER_BYTE (0)], &inferior_registers, memcpy (&deprecated_registers[REGISTER_BYTE (0)], &inferior_registers,
sizeof (inferior_registers)); sizeof (inferior_registers));
ptrace (PT_GETFPREGS, PIDGET (inferior_ptid), ptrace (PT_GETFPREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_fp_registers, 0); (PTRACE_ARG3_TYPE) & inferior_fp_registers, 0);
memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers, memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
sizeof (inferior_fp_registers)); sizeof (inferior_fp_registers));
deprecated_registers_fetched (); deprecated_registers_fetched ();
@ -53,12 +53,12 @@ store_inferior_registers (int regno)
struct reg inferior_registers; struct reg inferior_registers;
struct fpreg inferior_fp_registers; struct fpreg inferior_fp_registers;
memcpy (&inferior_registers, &registers[REGISTER_BYTE (0)], memcpy (&inferior_registers, &deprecated_registers[REGISTER_BYTE (0)],
sizeof (inferior_registers)); sizeof (inferior_registers));
ptrace (PT_SETREGS, PIDGET (inferior_ptid), ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_registers, 0); (PTRACE_ARG3_TYPE) & inferior_registers, 0);
memcpy (&inferior_fp_registers, &registers[REGISTER_BYTE (FP0_REGNUM)], memcpy (&inferior_fp_registers, &deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
sizeof (inferior_fp_registers)); sizeof (inferior_fp_registers));
ptrace (PT_SETFPREGS, PIDGET (inferior_ptid), ptrace (PT_SETFPREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_fp_registers, 0); (PTRACE_ARG3_TYPE) & inferior_fp_registers, 0);
@ -77,10 +77,10 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which,
struct md_core *core_reg = (struct md_core *) core_reg_sect; struct md_core *core_reg = (struct md_core *) core_reg_sect;
/* Integer registers */ /* Integer registers */
memcpy (&registers[REGISTER_BYTE (0)], memcpy (&deprecated_registers[REGISTER_BYTE (0)],
&core_reg->intreg, sizeof (struct reg)); &core_reg->intreg, sizeof (struct reg));
/* Floating point registers */ /* Floating point registers */
memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)], memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
&core_reg->freg, sizeof (struct fpreg)); &core_reg->freg, sizeof (struct fpreg));
} }

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

@ -132,7 +132,7 @@ fill_gregset (elf_gregset_t *gregsetp, int regno)
if (regno < 32) if (regno < 32)
{ {
src = &registers[REGISTER_BYTE (regno)]; src = &deprecated_registers[REGISTER_BYTE (regno)];
dst = regp + regno + EF_REG0; dst = regp + regno + EF_REG0;
memcpy (dst, src, sizeof (elf_greg_t)); memcpy (dst, src, sizeof (elf_greg_t));
return; return;
@ -163,7 +163,7 @@ fill_gregset (elf_gregset_t *gregsetp, int regno)
if (regaddr != -1) if (regaddr != -1)
{ {
src = &registers[REGISTER_BYTE (regno)]; src = &deprecated_registers[REGISTER_BYTE (regno)];
dst = regp + regaddr; dst = regp + regaddr;
memcpy (dst, src, sizeof (elf_greg_t)); memcpy (dst, src, sizeof (elf_greg_t));
} }
@ -199,13 +199,13 @@ fill_fpregset (elf_fpregset_t *fpregsetp, int regno)
if ((regno >= FP0_REGNUM) && (regno < FP0_REGNUM + 32)) if ((regno >= FP0_REGNUM) && (regno < FP0_REGNUM + 32))
{ {
from = (char *) &registers[REGISTER_BYTE (regno)]; from = (char *) &deprecated_registers[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, REGISTER_RAW_SIZE (regno - FP0_REGNUM));
} }
else if (regno == FCRCS_REGNUM) else if (regno == FCRCS_REGNUM)
{ {
from = (char *) &registers[REGISTER_BYTE (regno)]; from = (char *) &deprecated_registers[REGISTER_BYTE (regno)];
to = (char *) (*fpregsetp + 32); to = (char *) (*fpregsetp + 32);
memcpy (to, from, REGISTER_RAW_SIZE (regno)); memcpy (to, from, REGISTER_RAW_SIZE (regno));
} }

14
gdb/mipsm3-nat.c
View file

@ -122,14 +122,14 @@ static int reg_offset[] =
* Caller knows that the regs handled in one transaction are of same size. * Caller knows that the regs handled in one transaction are of same size.
*/ */
#define FETCH_REGS(state, regnum, count) \ #define FETCH_REGS(state, regnum, count) \
memcpy (&registers[REGISTER_BYTE (regnum)], \ memcpy (&deprecated_registers[REGISTER_BYTE (regnum)], \
(char *)state+reg_offset[ regnum ], \ (char *)state+reg_offset[ regnum ], \
count*REGISTER_SIZE) count*REGISTER_SIZE)
/* Store COUNT contiguous registers to thread STATE starting from REGNUM */ /* Store COUNT contiguous registers to thread STATE starting from REGNUM */
#define STORE_REGS(state, regnum, count) \ #define STORE_REGS(state, regnum, count) \
memcpy ((char *)state+reg_offset[ regnum ], \ memcpy ((char *)state+reg_offset[ regnum ], \
&registers[REGISTER_BYTE (regnum)], \ &deprecated_registers[REGISTER_BYTE (regnum)], \
count*REGISTER_SIZE) count*REGISTER_SIZE)
#define REGS_ALL -1 #define REGS_ALL -1
@ -204,7 +204,7 @@ fetch_inferior_registers (int regno)
} }
/* ZERO_REGNUM is always zero */ /* ZERO_REGNUM is always zero */
*(int *) registers = 0; *(int *) deprecated_registers = 0;
/* Copy thread saved regs 1..31 to gdb's reg value array /* Copy thread saved regs 1..31 to gdb's reg value array
* Luckily, they are contiquous * Luckily, they are contiquous
@ -259,7 +259,7 @@ fetch_inferior_registers (int regno)
/* If the thread does not have saved COPROC1, set regs to zero */ /* If the thread does not have saved COPROC1, set regs to zero */
if (!(exc_state.coproc_state & MIPS_STATUS_USE_COP1)) if (!(exc_state.coproc_state & MIPS_STATUS_USE_COP1))
bzero (&registers[REGISTER_BYTE (FP0_REGNUM)], bzero (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
sizeof (struct mips_float_state)); sizeof (struct mips_float_state));
else else
{ {
@ -324,7 +324,7 @@ store_inferior_registers (register int regno)
/* Don't allow these to change */ /* Don't allow these to change */
/* ZERO_REGNUM */ /* ZERO_REGNUM */
*(int *) registers = 0; *(int *) deprecated_registers = 0;
fetch_inferior_registers (PS_REGNUM); fetch_inferior_registers (PS_REGNUM);
fetch_inferior_registers (BADVADDR_REGNUM); fetch_inferior_registers (BADVADDR_REGNUM);
@ -342,8 +342,8 @@ store_inferior_registers (register int regno)
* should go to threads frame pointer. If not true, this * should go to threads frame pointer. If not true, this
* fails badly!!!!! * fails badly!!!!!
*/ */
memcpy (&registers[REGISTER_BYTE (MACH_FP_REGNUM)], memcpy (&deprecated_registers[REGISTER_BYTE (MACH_FP_REGNUM)],
&registers[REGISTER_BYTE (FP_REGNUM)], &deprecated_registers[REGISTER_BYTE (FP_REGNUM)],
REGISTER_RAW_SIZE (FP_REGNUM)); REGISTER_RAW_SIZE (FP_REGNUM));
#endif #endif

14
gdb/mipsv4-nat.c
View file

@ -75,19 +75,19 @@ fill_gregset (gregset_t *gregsetp, int regno)
for (regi = 0; regi <= 32; regi++) for (regi = 0; regi <= 32; regi++)
if ((regno == -1) || (regno == 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)) 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)) 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)) 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)) 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 @@ fill_fpregset (fpregset_t *fpregsetp, int regno)
{ {
if ((regno == -1) || (regno == regi)) if ((regno == -1) || (regno == regi))
{ {
from = (char *) &registers[REGISTER_BYTE (regi)]; from = (char *) &deprecated_registers[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, REGISTER_RAW_SIZE (regi));
} }
} }
if ((regno == -1) || (regno == FCRCS_REGNUM)) if ((regno == -1) || (regno == FCRCS_REGNUM))
fpregsetp->fp_csr = *(unsigned *) &registers[REGISTER_BYTE (FCRCS_REGNUM)]; fpregsetp->fp_csr = *(unsigned *) &deprecated_registers[REGISTER_BYTE (FCRCS_REGNUM)];
} }

4
gdb/ns32knbsd-nat.c
View file

@ -32,10 +32,10 @@
#include "regcache.h" #include "regcache.h"
#define RF(dst, src) \ #define RF(dst, src) \
memcpy(&registers[REGISTER_BYTE(dst)], &src, sizeof(src)) memcpy(&deprecated_registers[REGISTER_BYTE(dst)], &src, sizeof(src))
#define RS(src, dst) \ #define RS(src, dst) \
memcpy(&dst, &registers[REGISTER_BYTE(src)], sizeof(dst)) memcpy(&dst, &deprecated_registers[REGISTER_BYTE(src)], sizeof(dst))
void void
fetch_inferior_registers (int regno) fetch_inferior_registers (int regno)

2
gdb/ppc-bdm.c
View file

@ -295,7 +295,7 @@ bdm_ppc_store_registers (int regno)
&& ((i < FP0_REGNUM) || (i > FPLAST_REGNUM))) && ((i < FP0_REGNUM) || (i > FPLAST_REGNUM)))
{ {
/* printf("write valid reg %d\n", bdm_regno); */ /* 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) else if (i == gdbarch_tdep (current_gdbarch)->ppc_mq_regnum)

12
gdb/ppc-sysv-tdep.c
View file

@ -175,7 +175,7 @@ ppc_sysv_abi_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
{ {
char val_buf[4]; char val_buf[4];
store_address (val_buf, 4, struct_addr); store_address (val_buf, 4, struct_addr);
memcpy (&registers[REGISTER_BYTE (greg)], val_buf, 4); memcpy (&deprecated_registers[REGISTER_BYTE (greg)], val_buf, 4);
greg++; greg++;
} }
/* Now fill in the registers and stack... */ /* Now fill in the registers and stack... */
@ -192,7 +192,7 @@ ppc_sysv_abi_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
if (len > 8) if (len > 8)
printf_unfiltered ( printf_unfiltered (
"Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno); "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
memcpy (&registers[REGISTER_BYTE (FP0_REGNUM + freg)], memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM + freg)],
VALUE_CONTENTS (arg), len); VALUE_CONTENTS (arg), len);
freg++; freg++;
} }
@ -222,9 +222,9 @@ ppc_sysv_abi_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
if ((greg & 1) == 0) if ((greg & 1) == 0)
greg++; greg++;
memcpy (&registers[REGISTER_BYTE (greg)], memcpy (&deprecated_registers[REGISTER_BYTE (greg)],
VALUE_CONTENTS (arg), 4); VALUE_CONTENTS (arg), 4);
memcpy (&registers[REGISTER_BYTE (greg + 1)], memcpy (&deprecated_registers[REGISTER_BYTE (greg + 1)],
VALUE_CONTENTS (arg) + 4, 4); VALUE_CONTENTS (arg) + 4, 4);
greg += 2; greg += 2;
} }
@ -247,7 +247,7 @@ ppc_sysv_abi_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
} }
if (greg <= 10) if (greg <= 10)
{ {
memcpy (&registers[REGISTER_BYTE (greg)], val_buf, 4); memcpy (&deprecated_registers[REGISTER_BYTE (greg)], val_buf, 4);
greg++; greg++;
} }
else else
@ -268,7 +268,7 @@ ppc_sysv_abi_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
memcpy (v_val_buf, VALUE_CONTENTS (arg), len); memcpy (v_val_buf, VALUE_CONTENTS (arg), len);
if (vreg <= 13) if (vreg <= 13)
{ {
memcpy (&registers[REGISTER_BYTE (tdep->ppc_vr0_regnum memcpy (&deprecated_registers[REGISTER_BYTE (tdep->ppc_vr0_regnum
+ vreg)], + vreg)],
v_val_buf, 16); v_val_buf, 16);
vreg++; vreg++;

2
gdb/ptx4-nat.c
View file

@ -59,7 +59,7 @@ fill_gregset (gregset_t *gregsetp, int regno)
{ {
if ((regno == -1) || (regno == regi)) if ((regno == -1) || (regno == regi))
{ {
(*gregsetp)[regi] = *(greg_t *) & registers[REGISTER_BYTE (regi)]; (*gregsetp)[regi] = *(greg_t *) & deprecated_registers[REGISTER_BYTE (regi)];
} }
} }
} }

10
gdb/regcache.c
View file

@ -489,7 +489,7 @@ struct regcache *current_regcache;
/* REGISTERS contains the cached register values (in target byte order). */ /* 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, /* DEPRECATED_REGISTER_VALID is 0 if the register needs to be fetched,
1 if it has been fetched, and 1 if it has been fetched, and
@ -657,7 +657,7 @@ deprecated_read_register_bytes (int in_start, char *in_buf, int in_len)
/* FIXME: cagney/2001-08-18: This is just silly. It defeats /* FIXME: cagney/2001-08-18: This is just silly. It defeats
the entire register read/write flow of control. Must the entire register read/write flow of control. Must
resist temptation to return 0xdeadbeef. */ 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 /* Legacy note: This function, for some reason, allows a NULL
input buffer. If the buffer is NULL, the registers are still input buffer. If the buffer is NULL, the registers are still
@ -1000,7 +1000,7 @@ deprecated_write_register_bytes (int myregstart, char *myaddr, int inlen)
Update it from the target before scribbling on it. */ Update it from the target before scribbling on it. */
deprecated_read_register_gen (regnum, regbuf); deprecated_read_register_gen (regnum, regbuf);
memcpy (registers + overlapstart, memcpy (&deprecated_registers[overlapstart],
myaddr + (overlapstart - myregstart), myaddr + (overlapstart - myregstart),
overlapend - overlapstart); overlapend - overlapstart);
@ -1413,7 +1413,7 @@ build_regcache (void)
{ {
current_regcache = regcache_xmalloc (current_gdbarch); current_regcache = regcache_xmalloc (current_gdbarch);
current_regcache->readonly_p = 0; current_regcache->readonly_p = 0;
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); deprecated_register_valid = deprecated_grub_regcache_for_register_valid (current_regcache);
} }
@ -1695,7 +1695,7 @@ _initialize_regcache (void)
regcache_descr_handle = register_gdbarch_data (init_regcache_descr, regcache_descr_handle = register_gdbarch_data (init_regcache_descr,
xfree_regcache_descr); xfree_regcache_descr);
REGISTER_GDBARCH_SWAP (current_regcache); REGISTER_GDBARCH_SWAP (current_regcache);
register_gdbarch_swap (&registers, 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 (&deprecated_register_valid, sizeof (deprecated_register_valid), NULL);
register_gdbarch_swap (NULL, 0, build_regcache); register_gdbarch_swap (NULL, 0, build_regcache);

14
gdb/regcache.h
View file

@ -129,11 +129,6 @@ extern struct type *register_type (struct gdbarch *gdbarch, int regnum);
extern int max_register_size (struct gdbarch *gdbarch); 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;
/* Save/restore a register cache. The registers saved/restored is /* Save/restore a register cache. The registers saved/restored is
determined by the save_reggroup and restore_reggroup (although you determined by the save_reggroup and restore_reggroup (although you
can't restore a register that wasn't saved as well :-). You can can't restore a register that wasn't saved as well :-). You can
@ -192,6 +187,15 @@ extern void deprecated_write_register_bytes (int regbyte, char *myaddr,
available. */ available. */
extern signed char *deprecated_register_valid; extern signed char *deprecated_register_valid;
/* Character array containing an image of the inferior programs'
registers for the most recently referenced thread.
NOTE: cagney/2002-11-14: Target side code should be using
supply_register() and/or regcache_collect() while architecture side
code should use the more generic regcache methods. */
extern char *deprecated_registers;
/* NOTE: cagney/2002-11-05: This function, and its co-conspirator /* NOTE: cagney/2002-11-05: This function, and its co-conspirator
deprecated_registers[], have been superseeded by supply_register(). */ deprecated_registers[], have been superseeded by supply_register(). */
extern void deprecated_registers_fetched (void); extern void deprecated_registers_fetched (void);

20
gdb/remote-es.c
View file

@ -623,7 +623,7 @@ es1800_fetch_register (int regno)
{ {
error ("Emulator reply is too short: %s", buf); 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 else
@ -666,7 +666,7 @@ es1800_fetch_registers (void)
{ {
error ("Emulator reply is too short: %s", buf); 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; i += 2;
} }
} }
@ -685,7 +685,7 @@ es1800_fetch_registers (void)
{ {
error ("Emulator reply is too short: %s", buf); 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; i += 2;
} }
} }
@ -725,7 +725,7 @@ es1800_fetch_registers (void)
{ {
error ("Emulator reply is too short: %s", buf); 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; p = SR_buf;
@ -735,7 +735,7 @@ es1800_fetch_registers (void)
{ {
error ("Emulator reply is too short: %s", buf); 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]); fromhex (SR_buf[k * 2 + 1]) * 16 + fromhex (SR_buf[k * 2 + 2]);
} }
send_with_reply ("PC", buf, sizeof (buf)); send_with_reply ("PC", buf, sizeof (buf));
@ -746,7 +746,7 @@ es1800_fetch_registers (void)
{ {
error ("Emulator reply is too short: %s", buf); 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 else
@ -771,7 +771,7 @@ es1800_fetch_registers (void)
{ {
error ("Emulator reply is too short: %s", buf); 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 */ /* fetch STATUS */
@ -783,7 +783,7 @@ es1800_fetch_registers (void)
{ {
error ("Emulator reply is too short: %s", buf); 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]); fromhex (SR_buf[k * 2 + 1]) * 16 + fromhex (SR_buf[k * 2 + 2]);
} }
@ -797,7 +797,7 @@ es1800_fetch_registers (void)
{ {
error ("Emulator reply is too short: %s", buf); 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 @@ es1800_store_register (int regno)
int k; int k;
unsigned char *r; unsigned char *r;
r = (unsigned char *) registers; r = (unsigned char *) deprecated_registers;
if (regno == -1) /* write all registers */ if (regno == -1) /* write all registers */
{ {

4
gdb/remote-sds.c
View file

@ -528,7 +528,7 @@ sds_store_registers (int regno)
*p++ = 0; *p++ = 0;
*p++ = 0; *p++ = 0;
for (i = 0; i < 4 * 6; i++) 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++) for (i = 0; i < 4 * 1; i++)
*p++ = 0; *p++ = 0;
for (i = 0; i < 4 * 4; i++) for (i = 0; i < 4 * 4; i++)
@ -543,7 +543,7 @@ sds_store_registers (int regno)
*p++ = 0; *p++ = 0;
*p++ = 0; *p++ = 0;
for (i = 0; i < 4 * 32; i++) for (i = 0; i < 4 * 32; i++)
*p++ = registers[i]; *p++ = deprecated_registers[i];
sds_send (buf, p - buf); sds_send (buf, p - buf);

28
gdb/remote-vx68.c
View file

@ -85,10 +85,13 @@ vx_read_register (int regno)
net_read_registers (mc68k_greg_packet, MC68K_GREG_PLEN, PTRACE_GETREGS); 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_D0], deprecated_registers,
bcopy (&mc68k_greg_packet[MC68K_R_SR], &registers[REGISTER_BYTE (PS_REGNUM)], 16 * MC68K_GREG_SIZE);
bcopy (&mc68k_greg_packet[MC68K_R_SR],
&deprecated_registers[REGISTER_BYTE (PS_REGNUM)],
MC68K_GREG_SIZE); MC68K_GREG_SIZE);
bcopy (&mc68k_greg_packet[MC68K_R_PC], &registers[REGISTER_BYTE (PC_REGNUM)], bcopy (&mc68k_greg_packet[MC68K_R_PC],
&deprecated_registers[REGISTER_BYTE (PC_REGNUM)],
MC68K_GREG_SIZE); MC68K_GREG_SIZE);
/* Get floating-point registers, if the target system has them. /* Get floating-point registers, if the target system has them.
@ -100,17 +103,17 @@ vx_read_register (int regno)
PTRACE_GETFPREGS); PTRACE_GETFPREGS);
bcopy (&mc68k_fpreg_packet[MC68K_R_FP0], bcopy (&mc68k_fpreg_packet[MC68K_R_FP0],
&registers[REGISTER_BYTE (FP0_REGNUM)], &deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
MC68K_FPREG_SIZE * 8); MC68K_FPREG_SIZE * 8);
bcopy (&mc68k_fpreg_packet[MC68K_R_FPCR], bcopy (&mc68k_fpreg_packet[MC68K_R_FPCR],
&registers[REGISTER_BYTE (FPC_REGNUM)], &deprecated_registers[REGISTER_BYTE (FPC_REGNUM)],
MC68K_FPREG_PLEN - (MC68K_FPREG_SIZE * 8)); MC68K_FPREG_PLEN - (MC68K_FPREG_SIZE * 8));
} }
else else
{ {
bzero (&registers[REGISTER_BYTE (FP0_REGNUM)], bzero (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
MC68K_FPREG_SIZE * 8); MC68K_FPREG_SIZE * 8);
bzero (&registers[REGISTER_BYTE (FPC_REGNUM)], bzero (&deprecated_registers[REGISTER_BYTE (FPC_REGNUM)],
MC68K_FPREG_PLEN - (MC68K_FPREG_SIZE * 8)); MC68K_FPREG_PLEN - (MC68K_FPREG_SIZE * 8));
} }
@ -131,10 +134,11 @@ vx_write_register (int regno)
/* Store general-purpose registers. */ /* Store general-purpose registers. */
bcopy (registers, &mc68k_greg_packet[MC68K_R_D0], 16 * MC68K_GREG_SIZE); bcopy (deprecated_registers, &mc68k_greg_packet[MC68K_R_D0],
bcopy (&registers[REGISTER_BYTE (PS_REGNUM)], 16 * MC68K_GREG_SIZE);
bcopy (&deprecated_registers[REGISTER_BYTE (PS_REGNUM)],
&mc68k_greg_packet[MC68K_R_SR], MC68K_GREG_SIZE); &mc68k_greg_packet[MC68K_R_SR], MC68K_GREG_SIZE);
bcopy (&registers[REGISTER_BYTE (PC_REGNUM)], bcopy (&deprecated_registers[REGISTER_BYTE (PC_REGNUM)],
&mc68k_greg_packet[MC68K_R_PC], MC68K_GREG_SIZE); &mc68k_greg_packet[MC68K_R_PC], MC68K_GREG_SIZE);
net_write_registers (mc68k_greg_packet, MC68K_GREG_PLEN, PTRACE_SETREGS); net_write_registers (mc68k_greg_packet, MC68K_GREG_PLEN, PTRACE_SETREGS);
@ -143,10 +147,10 @@ vx_write_register (int regno)
if (target_has_fp) if (target_has_fp)
{ {
bcopy (&registers[REGISTER_BYTE (FP0_REGNUM)], bcopy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
&mc68k_fpreg_packet[MC68K_R_FP0], &mc68k_fpreg_packet[MC68K_R_FP0],
MC68K_FPREG_SIZE * 8); MC68K_FPREG_SIZE * 8);
bcopy (&registers[REGISTER_BYTE (FPC_REGNUM)], bcopy (&deprecated_registers[REGISTER_BYTE (FPC_REGNUM)],
&mc68k_fpreg_packet[MC68K_R_FPCR], &mc68k_fpreg_packet[MC68K_R_FPCR],
MC68K_FPREG_PLEN - (MC68K_FPREG_SIZE * 8)); MC68K_FPREG_PLEN - (MC68K_FPREG_SIZE * 8));

34
gdb/remote-vxmips.c
View file

@ -103,18 +103,19 @@ vx_read_register (int regno)
/* Copy the general registers. */ /* Copy the general registers. */
bcopy (&mips_greg_packet[MIPS_R_GP0], &registers[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. */ /* Copy SR, LO, HI, and PC. */
bcopy (&mips_greg_packet[MIPS_R_SR], bcopy (&mips_greg_packet[MIPS_R_SR],
&registers[REGISTER_BYTE (PS_REGNUM)], MIPS_GREG_SIZE); &deprecated_registers[REGISTER_BYTE (PS_REGNUM)], MIPS_GREG_SIZE);
bcopy (&mips_greg_packet[MIPS_R_LO], bcopy (&mips_greg_packet[MIPS_R_LO],
&registers[REGISTER_BYTE (LO_REGNUM)], MIPS_GREG_SIZE); &deprecated_registers[REGISTER_BYTE (LO_REGNUM)], MIPS_GREG_SIZE);
bcopy (&mips_greg_packet[MIPS_R_HI], bcopy (&mips_greg_packet[MIPS_R_HI],
&registers[REGISTER_BYTE (HI_REGNUM)], MIPS_GREG_SIZE); &deprecated_registers[REGISTER_BYTE (HI_REGNUM)], MIPS_GREG_SIZE);
bcopy (&mips_greg_packet[MIPS_R_PC], bcopy (&mips_greg_packet[MIPS_R_PC],
&registers[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. /* 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
@ -129,20 +130,20 @@ vx_read_register (int regno)
/* Copy the floating point registers. */ /* Copy the floating point registers. */
bcopy (&mips_fpreg_packet[MIPS_R_FP0], bcopy (&mips_fpreg_packet[MIPS_R_FP0],
&registers[REGISTER_BYTE (FP0_REGNUM)], &deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
REGISTER_RAW_SIZE (FP0_REGNUM) * 32); 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],
&registers[REGISTER_BYTE (FCRCS_REGNUM)], &deprecated_registers[REGISTER_BYTE (FCRCS_REGNUM)],
REGISTER_RAW_SIZE (FCRCS_REGNUM)); REGISTER_RAW_SIZE (FCRCS_REGNUM));
} }
else else
{ {
bzero ((char *) &registers[REGISTER_BYTE (FP0_REGNUM)], bzero ((char *) &deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
REGISTER_RAW_SIZE (FP0_REGNUM) * 32); REGISTER_RAW_SIZE (FP0_REGNUM) * 32);
bzero ((char *) &registers[REGISTER_BYTE (FCRCS_REGNUM)], bzero ((char *) &deprecated_registers[REGISTER_BYTE (FCRCS_REGNUM)],
REGISTER_RAW_SIZE (FCRCS_REGNUM)); REGISTER_RAW_SIZE (FCRCS_REGNUM));
} }
@ -162,17 +163,18 @@ vx_write_register (int regno)
/* Store general registers. */ /* Store general registers. */
bcopy (&registers[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. */ /* Copy SR, LO, HI, and PC. */
bcopy (&registers[REGISTER_BYTE (PS_REGNUM)], bcopy (&deprecated_registers[REGISTER_BYTE (PS_REGNUM)],
&mips_greg_packet[MIPS_R_SR], MIPS_GREG_SIZE); &mips_greg_packet[MIPS_R_SR], MIPS_GREG_SIZE);
bcopy (&registers[REGISTER_BYTE (LO_REGNUM)], bcopy (&deprecated_registers[REGISTER_BYTE (LO_REGNUM)],
&mips_greg_packet[MIPS_R_LO], MIPS_GREG_SIZE); &mips_greg_packet[MIPS_R_LO], MIPS_GREG_SIZE);
bcopy (&registers[REGISTER_BYTE (HI_REGNUM)], bcopy (&deprecated_registers[REGISTER_BYTE (HI_REGNUM)],
&mips_greg_packet[MIPS_R_HI], MIPS_GREG_SIZE); &mips_greg_packet[MIPS_R_HI], MIPS_GREG_SIZE);
bcopy (&registers[REGISTER_BYTE (PC_REGNUM)], bcopy (&deprecated_registers[REGISTER_BYTE (PC_REGNUM)],
&mips_greg_packet[MIPS_R_PC], MIPS_GREG_SIZE); &mips_greg_packet[MIPS_R_PC], MIPS_GREG_SIZE);
net_write_registers (mips_greg_packet, MIPS_GREG_PLEN, PTRACE_SETREGS); net_write_registers (mips_greg_packet, MIPS_GREG_PLEN, PTRACE_SETREGS);
@ -183,13 +185,13 @@ vx_write_register (int regno)
{ {
/* Copy the floating point data registers. */ /* Copy the floating point data registers. */
bcopy (&registers[REGISTER_BYTE (FP0_REGNUM)], bcopy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
&mips_fpreg_packet[MIPS_R_FP0], &mips_fpreg_packet[MIPS_R_FP0],
REGISTER_RAW_SIZE (FP0_REGNUM) * 32); REGISTER_RAW_SIZE (FP0_REGNUM) * 32);
/* Copy the floating point control/status register (fpcsr). */ /* Copy the floating point control/status register (fpcsr). */
bcopy (&registers[REGISTER_BYTE (FCRCS_REGNUM)], bcopy (&deprecated_registers[REGISTER_BYTE (FCRCS_REGNUM)],
&mips_fpreg_packet[MIPS_R_FPCSR], &mips_fpreg_packet[MIPS_R_FPCSR],
REGISTER_RAW_SIZE (FCRCS_REGNUM)); REGISTER_RAW_SIZE (FCRCS_REGNUM));

33
gdb/remote-vxsparc.c
View file

@ -92,18 +92,19 @@ vx_read_register (int regno)
as defined in "tm-sparc.h". */ as defined in "tm-sparc.h". */
bcopy (&sparc_greg_packet[SPARC_R_G0], bcopy (&sparc_greg_packet[SPARC_R_G0],
&registers[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], bcopy (&sparc_greg_packet[SPARC_R_Y],
&registers[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 /* Now write the local and in registers to the register window
spill area in the frame. VxWorks does not do this for the spill area in the frame. VxWorks does not do this for the
active frame automatically; it greatly simplifies debugging active frame automatically; it greatly simplifies debugging
(FRAME_FIND_SAVED_REGS, in particular, depends on this). */ (FRAME_FIND_SAVED_REGS, in particular, depends on this). */
sp = extract_address (&registers[REGISTER_BYTE (SP_REGNUM)], sp = extract_address (&deprecated_registers[REGISTER_BYTE (SP_REGNUM)],
REGISTER_RAW_SIZE (SP_REGNUM)); REGISTER_RAW_SIZE (SP_REGNUM));
write_memory (sp, &registers[REGISTER_BYTE (L0_REGNUM)], write_memory (sp, &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
16 * REGISTER_RAW_SIZE (L0_REGNUM)); 16 * REGISTER_RAW_SIZE (L0_REGNUM));
/* If the target has floating point registers, fetch them. /* If the target has floating point registers, fetch them.
@ -116,14 +117,18 @@ vx_read_register (int regno)
net_read_registers (sparc_fpreg_packet, SPARC_FPREG_PLEN, net_read_registers (sparc_fpreg_packet, SPARC_FPREG_PLEN,
PTRACE_GETFPREGS); PTRACE_GETFPREGS);
bcopy (&sparc_fpreg_packet[SPARC_R_FP0], bcopy (&sparc_fpreg_packet[SPARC_R_FP0],
&registers[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], bcopy (&sparc_fpreg_packet[SPARC_R_FSR],
&registers[REGISTER_BYTE (FPS_REGNUM)], 1 * SPARC_FPREG_SIZE); &deprecated_registers[REGISTER_BYTE (FPS_REGNUM)],
1 * SPARC_FPREG_SIZE);
} }
else else
{ {
bzero (&registers[REGISTER_BYTE (FP0_REGNUM)], 32 * SPARC_FPREG_SIZE); bzero (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
bzero (&registers[REGISTER_BYTE (FPS_REGNUM)], 1 * SPARC_FPREG_SIZE); 32 * SPARC_FPREG_SIZE);
bzero (&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)],
1 * SPARC_FPREG_SIZE);
} }
/* Mark the register cache valid. */ /* Mark the register cache valid. */
@ -160,9 +165,9 @@ vx_write_register (int regno)
} }
if (in_gp_regs) if (in_gp_regs)
{ {
bcopy (&registers[REGISTER_BYTE (G0_REGNUM)], bcopy (&deprecated_registers[REGISTER_BYTE (G0_REGNUM)],
&sparc_greg_packet[SPARC_R_G0], 32 * SPARC_GREG_SIZE); &sparc_greg_packet[SPARC_R_G0], 32 * SPARC_GREG_SIZE);
bcopy (&registers[REGISTER_BYTE (Y_REGNUM)], bcopy (&deprecated_registers[REGISTER_BYTE (Y_REGNUM)],
&sparc_greg_packet[SPARC_R_Y], 6 * SPARC_GREG_SIZE); &sparc_greg_packet[SPARC_R_Y], 6 * SPARC_GREG_SIZE);
net_write_registers (sparc_greg_packet, SPARC_GREG_PLEN, PTRACE_SETREGS); net_write_registers (sparc_greg_packet, SPARC_GREG_PLEN, PTRACE_SETREGS);
@ -172,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_address (&registers[REGISTER_BYTE (SP_REGNUM)], sp = extract_address (&deprecated_registers[REGISTER_BYTE (SP_REGNUM)],
REGISTER_RAW_SIZE (SP_REGNUM)); REGISTER_RAW_SIZE (SP_REGNUM));
write_memory (sp, &registers[REGISTER_BYTE (L0_REGNUM)], write_memory (sp, &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
16 * REGISTER_RAW_SIZE (L0_REGNUM)); 16 * REGISTER_RAW_SIZE (L0_REGNUM));
} }
} }
@ -183,9 +188,9 @@ vx_write_register (int regno)
if (in_fp_regs && target_has_fp) if (in_fp_regs && target_has_fp)
{ {
bcopy (&registers[REGISTER_BYTE (FP0_REGNUM)], bcopy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
&sparc_fpreg_packet[SPARC_R_FP0], 32 * SPARC_FPREG_SIZE); &sparc_fpreg_packet[SPARC_R_FP0], 32 * SPARC_FPREG_SIZE);
bcopy (&registers[REGISTER_BYTE (FPS_REGNUM)], bcopy (&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)],
&sparc_fpreg_packet[SPARC_R_FSR], 1 * SPARC_FPREG_SIZE); &sparc_fpreg_packet[SPARC_R_FSR], 1 * SPARC_FPREG_SIZE);
net_write_registers (sparc_fpreg_packet, SPARC_FPREG_PLEN, net_write_registers (sparc_fpreg_packet, SPARC_FPREG_PLEN,

18
gdb/rs6000-tdep.c
View file

@ -995,7 +995,8 @@ rs6000_pop_frame (void)
addr = prev_sp + fdata.gpr_offset; addr = prev_sp + fdata.gpr_offset;
for (ii = fdata.saved_gpr; ii <= 31; ++ii) for (ii = fdata.saved_gpr; ii <= 31; ++ii)
{ {
read_memory (addr, &registers[REGISTER_BYTE (ii)], wordsize); read_memory (addr, &deprecated_registers[REGISTER_BYTE (ii)],
wordsize);
addr += wordsize; addr += wordsize;
} }
} }
@ -1005,7 +1006,7 @@ rs6000_pop_frame (void)
addr = prev_sp + fdata.fpr_offset; addr = prev_sp + fdata.fpr_offset;
for (ii = fdata.saved_fpr; ii <= 31; ++ii) for (ii = fdata.saved_fpr; ii <= 31; ++ii)
{ {
read_memory (addr, &registers[REGISTER_BYTE (ii + FP0_REGNUM)], 8); read_memory (addr, &deprecated_registers[REGISTER_BYTE (ii + FP0_REGNUM)], 8);
addr += 8; addr += 8;
} }
} }
@ -1122,7 +1123,7 @@ rs6000_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
printf_unfiltered ( printf_unfiltered (
"Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno); "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
memcpy (&registers[REGISTER_BYTE (FP0_REGNUM + 1 + f_argno)], memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM + 1 + f_argno)],
VALUE_CONTENTS (arg), VALUE_CONTENTS (arg),
len); len);
++f_argno; ++f_argno;
@ -1134,8 +1135,9 @@ rs6000_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
/* Argument takes more than one register. */ /* Argument takes more than one register. */
while (argbytes < len) while (argbytes < len)
{ {
memset (&registers[REGISTER_BYTE (ii + 3)], 0, reg_size); memset (&deprecated_registers[REGISTER_BYTE (ii + 3)], 0,
memcpy (&registers[REGISTER_BYTE (ii + 3)], reg_size);
memcpy (&deprecated_registers[REGISTER_BYTE (ii + 3)],
((char *) VALUE_CONTENTS (arg)) + argbytes, ((char *) VALUE_CONTENTS (arg)) + argbytes,
(len - argbytes) > reg_size (len - argbytes) > reg_size
? reg_size : len - argbytes); ? reg_size : len - argbytes);
@ -1151,8 +1153,8 @@ rs6000_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
{ {
/* Argument can fit in one register. No problem. */ /* Argument can fit in one register. No problem. */
int adj = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? reg_size - len : 0; int adj = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? reg_size - len : 0;
memset (&registers[REGISTER_BYTE (ii + 3)], 0, reg_size); memset (&deprecated_registers[REGISTER_BYTE (ii + 3)], 0, reg_size);
memcpy ((char *)&registers[REGISTER_BYTE (ii + 3)] + adj, memcpy ((char *)&deprecated_registers[REGISTER_BYTE (ii + 3)] + adj,
VALUE_CONTENTS (arg), len); VALUE_CONTENTS (arg), len);
} }
++argno; ++argno;
@ -1234,7 +1236,7 @@ ran_out_of_registers_for_arguments:
printf_unfiltered ( printf_unfiltered (
"Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno); "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
memcpy (&registers[REGISTER_BYTE (FP0_REGNUM + 1 + f_argno)], memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM + 1 + f_argno)],
VALUE_CONTENTS (arg), VALUE_CONTENTS (arg),
len); len);
++f_argno; ++f_argno;

6
gdb/sol-thread.c
View file

@ -648,7 +648,8 @@ sol_thread_store_registers (int regno)
{ /* Not writing all the regs */ { /* Not writing all the regs */
/* save new register value */ /* save new register value */
char* old_value = (char*) alloca (REGISTER_SIZE); char* old_value = (char*) alloca (REGISTER_SIZE);
memcpy (old_value, &registers[REGISTER_BYTE (regno)], REGISTER_SIZE); memcpy (old_value, &deprecated_registers[REGISTER_BYTE (regno)],
REGISTER_SIZE);
val = p_td_thr_getgregs (&thandle, gregset); val = p_td_thr_getgregs (&thandle, gregset);
if (val != TD_OK) if (val != TD_OK)
@ -660,7 +661,8 @@ sol_thread_store_registers (int regno)
td_err_string (val)); td_err_string (val));
/* restore new register value */ /* restore new register value */
memcpy (&registers[REGISTER_BYTE (regno)], old_value, REGISTER_SIZE); memcpy (&deprecated_registers[REGISTER_BYTE (regno)], old_value,
REGISTER_SIZE);
#if 0 #if 0
/* thread_db doesn't seem to handle this right */ /* thread_db doesn't seem to handle this right */

80
gdb/sparc-nat.c
View file

@ -79,12 +79,15 @@ fetch_inferior_registers (int regno)
(PTRACE_ARG3_TYPE) & inferior_registers, 0)) (PTRACE_ARG3_TYPE) & inferior_registers, 0))
perror ("ptrace_getregs"); perror ("ptrace_getregs");
registers[REGISTER_BYTE (0)] = 0; deprecated_registers[REGISTER_BYTE (0)] = 0;
memcpy (&registers[REGISTER_BYTE (1)], &inferior_registers.r_g1, memcpy (&deprecated_registers[REGISTER_BYTE (1)],
15 * REGISTER_RAW_SIZE (G0_REGNUM)); &inferior_registers.r_g1, 15 * REGISTER_RAW_SIZE (G0_REGNUM));
*(int *) &registers[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps; *(int *) &deprecated_registers[REGISTER_BYTE (PS_REGNUM)]
*(int *) &registers[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc; = inferior_registers.r_ps;
*(int *) &registers[REGISTER_BYTE (NPC_REGNUM)] = inferior_registers.r_npc; *(int *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)]
= inferior_registers.r_pc;
*(int *) &deprecated_registers[REGISTER_BYTE (NPC_REGNUM)]
= inferior_registers.r_npc;
*(int *) &registers[REGISTER_BYTE (Y_REGNUM)] = inferior_registers.r_y; *(int *) &registers[REGISTER_BYTE (Y_REGNUM)] = inferior_registers.r_y;
for (i = G0_REGNUM; i <= O7_REGNUM; i++) for (i = G0_REGNUM; i <= O7_REGNUM; i++)
@ -109,11 +112,10 @@ fetch_inferior_registers (int regno)
(PTRACE_ARG3_TYPE) & inferior_fp_registers, (PTRACE_ARG3_TYPE) & inferior_fp_registers,
0)) 0))
perror ("ptrace_getfpregs"); perror ("ptrace_getfpregs");
memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers, memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
sizeof inferior_fp_registers.fpu_fr); &inferior_fp_registers, sizeof inferior_fp_registers.fpu_fr);
memcpy (&registers[REGISTER_BYTE (FPS_REGNUM)], memcpy (&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)],
&inferior_fp_registers.Fpu_fsr, &inferior_fp_registers.Fpu_fsr, sizeof (FPU_FSR_TYPE));
sizeof (FPU_FSR_TYPE));
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;
deprecated_register_valid[FPS_REGNUM] = 1; deprecated_register_valid[FPS_REGNUM] = 1;
@ -123,20 +125,20 @@ fetch_inferior_registers (int regno)
all (16 ptrace calls!) if we really need them. */ all (16 ptrace calls!) if we really need them. */
if (regno == -1) if (regno == -1)
{ {
CORE_ADDR sp = *(unsigned int *) & registers[REGISTER_BYTE (SP_REGNUM)]; CORE_ADDR sp = *(unsigned int *) & deprecated_registers[REGISTER_BYTE (SP_REGNUM)];
target_read_memory (sp, &registers[REGISTER_BYTE (L0_REGNUM)], target_read_memory (sp, &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
16 * REGISTER_RAW_SIZE (L0_REGNUM)); 16 * 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;
} }
else if (regno >= L0_REGNUM && regno <= I7_REGNUM) 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); i = REGISTER_BYTE (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 - REGISTER_BYTE (L0_REGNUM), target_read_memory (sp + i - REGISTER_BYTE (L0_REGNUM),
&registers[i], REGISTER_RAW_SIZE (regno)); &deprecated_registers[i], REGISTER_RAW_SIZE (regno));
deprecated_register_valid[regno] = 1; deprecated_register_valid[regno] = 1;
} }
} }
@ -195,14 +197,14 @@ store_inferior_registers (int regno)
if (wanna_store & STACK_REGS) 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 (regno < 0 || regno == SP_REGNUM)
{ {
if (!deprecated_register_valid[L0_REGNUM + 5]) if (!deprecated_register_valid[L0_REGNUM + 5])
internal_error (__FILE__, __LINE__, "failed internal consistency check"); internal_error (__FILE__, __LINE__, "failed internal consistency check");
target_write_memory (sp, target_write_memory (sp,
&registers[REGISTER_BYTE (L0_REGNUM)], &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
16 * REGISTER_RAW_SIZE (L0_REGNUM)); 16 * REGISTER_RAW_SIZE (L0_REGNUM));
} }
else else
@ -210,7 +212,7 @@ store_inferior_registers (int regno)
if (!deprecated_register_valid[regno]) if (!deprecated_register_valid[regno])
internal_error (__FILE__, __LINE__, "failed internal consistency check"); internal_error (__FILE__, __LINE__, "failed internal consistency check");
target_write_memory (sp + REGISTER_BYTE (regno) - REGISTER_BYTE (L0_REGNUM), target_write_memory (sp + REGISTER_BYTE (regno) - REGISTER_BYTE (L0_REGNUM),
&registers[REGISTER_BYTE (regno)], &deprecated_registers[REGISTER_BYTE (regno)],
REGISTER_RAW_SIZE (regno)); REGISTER_RAW_SIZE (regno));
} }
@ -221,17 +223,18 @@ store_inferior_registers (int regno)
if (!deprecated_register_valid[G1_REGNUM]) if (!deprecated_register_valid[G1_REGNUM])
internal_error (__FILE__, __LINE__, "failed internal consistency check"); internal_error (__FILE__, __LINE__, "failed internal consistency check");
memcpy (&inferior_registers.r_g1, &registers[REGISTER_BYTE (G1_REGNUM)], memcpy (&inferior_registers.r_g1,
&deprecated_registers[REGISTER_BYTE (G1_REGNUM)],
15 * REGISTER_RAW_SIZE (G1_REGNUM)); 15 * REGISTER_RAW_SIZE (G1_REGNUM));
inferior_registers.r_ps = inferior_registers.r_ps =
*(int *) &registers[REGISTER_BYTE (PS_REGNUM)]; *(int *) &deprecated_registers[REGISTER_BYTE (PS_REGNUM)];
inferior_registers.r_pc = inferior_registers.r_pc =
*(int *) &registers[REGISTER_BYTE (PC_REGNUM)]; *(int *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)];
inferior_registers.r_npc = inferior_registers.r_npc =
*(int *) &registers[REGISTER_BYTE (NPC_REGNUM)]; *(int *) &deprecated_registers[REGISTER_BYTE (NPC_REGNUM)];
inferior_registers.r_y = inferior_registers.r_y =
*(int *) &registers[REGISTER_BYTE (Y_REGNUM)]; *(int *) &deprecated_registers[REGISTER_BYTE (Y_REGNUM)];
if (0 != ptrace (PTRACE_SETREGS, PIDGET (inferior_ptid), if (0 != ptrace (PTRACE_SETREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_registers, 0)) (PTRACE_ARG3_TYPE) & inferior_registers, 0))
@ -242,10 +245,12 @@ store_inferior_registers (int regno)
{ {
if (!deprecated_register_valid[FP0_REGNUM + 9]) if (!deprecated_register_valid[FP0_REGNUM + 9])
internal_error (__FILE__, __LINE__, "failed internal consistency check"); internal_error (__FILE__, __LINE__, "failed internal consistency check");
memcpy (&inferior_fp_registers, &registers[REGISTER_BYTE (FP0_REGNUM)], memcpy (&inferior_fp_registers,
&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
sizeof inferior_fp_registers.fpu_fr); sizeof inferior_fp_registers.fpu_fr);
memcpy (&inferior_fp_registers.Fpu_fsr, memcpy (&inferior_fp_registers.Fpu_fsr,
&registers[REGISTER_BYTE (FPS_REGNUM)], sizeof (FPU_FSR_TYPE)); &deprecated_registers[REGISTER_BYTE (FPS_REGNUM)],
sizeof (FPU_FSR_TYPE));
if (0 != if (0 !=
ptrace (PTRACE_SETFPREGS, PIDGET (inferior_ptid), ptrace (PTRACE_SETFPREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_fp_registers, 0)) (PTRACE_ARG3_TYPE) & inferior_fp_registers, 0))
@ -277,15 +282,15 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
#define gregs ((struct regs *)core_reg_sect) #define gregs ((struct regs *)core_reg_sect)
/* G0 *always* holds 0. */ /* G0 *always* holds 0. */
*(int *) &registers[REGISTER_BYTE (0)] = 0; *(int *) &deprecated_registers[REGISTER_BYTE (0)] = 0;
/* The globals and output registers. */ /* The globals and output registers. */
memcpy (&registers[REGISTER_BYTE (G1_REGNUM)], &gregs->r_g1, memcpy (&deprecated_registers[REGISTER_BYTE (G1_REGNUM)], &gregs->r_g1,
15 * REGISTER_RAW_SIZE (G1_REGNUM)); 15 * REGISTER_RAW_SIZE (G1_REGNUM));
*(int *) &registers[REGISTER_BYTE (PS_REGNUM)] = gregs->r_ps; *(int *) &deprecated_registers[REGISTER_BYTE (PS_REGNUM)] = gregs->r_ps;
*(int *) &registers[REGISTER_BYTE (PC_REGNUM)] = gregs->r_pc; *(int *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)] = gregs->r_pc;
*(int *) &registers[REGISTER_BYTE (NPC_REGNUM)] = gregs->r_npc; *(int *) &deprecated_registers[REGISTER_BYTE (NPC_REGNUM)] = gregs->r_npc;
*(int *) &registers[REGISTER_BYTE (Y_REGNUM)] = gregs->r_y; *(int *) &deprecated_registers[REGISTER_BYTE (Y_REGNUM)] = gregs->r_y;
/* My best guess at where to get the locals and input /* My best guess at where to get the locals and input
registers is exactly where they usually are, right above registers is exactly where they usually are, right above
@ -295,8 +300,9 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
{ {
int sp; int sp;
sp = *(int *) &registers[REGISTER_BYTE (SP_REGNUM)]; sp = *(int *) &deprecated_registers[REGISTER_BYTE (SP_REGNUM)];
if (0 != target_read_memory (sp, &registers[REGISTER_BYTE (L0_REGNUM)], if (0 != target_read_memory (sp,
&deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
16 * REGISTER_RAW_SIZE (L0_REGNUM))) 16 * REGISTER_RAW_SIZE (L0_REGNUM)))
{ {
/* fprintf_unfiltered so user can still use gdb */ /* fprintf_unfiltered so user can still use gdb */
@ -313,10 +319,10 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
#define fpuregs ((struct fpu *) core_reg_sect) #define fpuregs ((struct fpu *) core_reg_sect)
if (core_reg_size >= sizeof (struct fpu)) if (core_reg_size >= sizeof (struct fpu))
{ {
memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)], fpuregs->fpu_regs, memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
sizeof (fpuregs->fpu_regs)); fpuregs->fpu_regs, sizeof (fpuregs->fpu_regs));
memcpy (&registers[REGISTER_BYTE (FPS_REGNUM)], &fpuregs->fpu_fsr, memcpy (&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)],
sizeof (FPU_FSR_TYPE)); &fpuregs->fpu_fsr, sizeof (FPU_FSR_TYPE));
} }
else else
fprintf_unfiltered (gdb_stderr, "Couldn't read float regs from core file\n"); fprintf_unfiltered (gdb_stderr, "Couldn't read float regs from core file\n");

4
gdb/sparc-tdep.c
View file

@ -1729,7 +1729,7 @@ fill_fpregset (gdb_fpregset_t *fpregsetp, int regno)
{ {
if ((regno == -1) || (regno == regi)) if ((regno == -1) || (regno == regi))
{ {
from = (char *) &registers[REGISTER_BYTE (regi)]; from = (char *) &deprecated_registers[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, REGISTER_RAW_SIZE (regi));
} }
@ -1738,7 +1738,7 @@ fill_fpregset (gdb_fpregset_t *fpregsetp, int regno)
if (!(GDB_TARGET_IS_SPARC64)) /* FIXME: does Sparc64 have this register? */ if (!(GDB_TARGET_IS_SPARC64)) /* FIXME: does Sparc64 have this register? */
if ((regno == -1) || (regno == FPS_REGNUM)) if ((regno == -1) || (regno == FPS_REGNUM))
{ {
from = (char *)&registers[REGISTER_BYTE (FPS_REGNUM)]; from = (char *)&deprecated_registers[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, REGISTER_RAW_SIZE (FPS_REGNUM));
} }

29
gdb/sun3-nat.c
View file

@ -45,15 +45,15 @@ fetch_inferior_registers (int regno)
ptrace (PTRACE_GETFPREGS, PIDGET (inferior_ptid), ptrace (PTRACE_GETFPREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_fp_registers); (PTRACE_ARG3_TYPE) & inferior_fp_registers);
memcpy (registers, &inferior_registers, 16 * 4); memcpy (deprecated_registers, &inferior_registers, 16 * 4);
if (FP0_REGNUM >= 0) if (FP0_REGNUM >= 0)
memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers, memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
sizeof inferior_fp_registers.fps_regs); &inferior_fp_registers, sizeof inferior_fp_registers.fps_regs);
*(int *) &registers[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps; *(int *) &deprecated_registers[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps;
*(int *) &registers[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc; *(int *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc;
if (FP0_REGNUM >= 0) if (FP0_REGNUM >= 0)
memcpy (&registers[REGISTER_BYTE (FPC_REGNUM)], memcpy (&deprecated_registers[REGISTER_BYTE (FPC_REGNUM)],
&inferior_fp_registers.fps_control, &inferior_fp_registers.fps_control,
sizeof inferior_fp_registers - sizeof inferior_fp_registers -
sizeof inferior_fp_registers.fps_regs); sizeof inferior_fp_registers.fps_regs);
@ -69,17 +69,18 @@ store_inferior_registers (int regno)
struct regs inferior_registers; struct regs inferior_registers;
struct fp_status inferior_fp_registers; struct fp_status inferior_fp_registers;
memcpy (&inferior_registers, registers, 16 * 4); memcpy (&inferior_registers, deprecated_registers, 16 * 4);
if (FP0_REGNUM >= 0) if (FP0_REGNUM >= 0)
memcpy (&inferior_fp_registers, &registers[REGISTER_BYTE (FP0_REGNUM)], memcpy (&inferior_fp_registers,
&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
sizeof inferior_fp_registers.fps_regs); sizeof inferior_fp_registers.fps_regs);
inferior_registers.r_ps = *(int *) &registers[REGISTER_BYTE (PS_REGNUM)]; inferior_registers.r_ps = *(int *) &&deprecated_registers[REGISTER_BYTE (PS_REGNUM)];
inferior_registers.r_pc = *(int *) &registers[REGISTER_BYTE (PC_REGNUM)]; inferior_registers.r_pc = *(int *) &&deprecated_registers[REGISTER_BYTE (PC_REGNUM)];
if (FP0_REGNUM >= 0) if (FP0_REGNUM >= 0)
memcpy (&inferior_fp_registers.fps_control, memcpy (&inferior_fp_registers.fps_control,
&registers[REGISTER_BYTE (FPC_REGNUM)], &&deprecated_registers[REGISTER_BYTE (FPC_REGNUM)],
sizeof inferior_fp_registers - sizeof inferior_fp_registers -
sizeof inferior_fp_registers.fps_regs); sizeof inferior_fp_registers.fps_regs);
@ -116,7 +117,7 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
if (core_reg_size < sizeof (struct regs)) if (core_reg_size < sizeof (struct regs))
error ("Can't find registers in core file"); 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 *) &regs->r_ps); supply_register (PS_REGNUM, (char *) &regs->r_ps);
supply_register (PC_REGNUM, (char *) &regs->r_pc); supply_register (PC_REGNUM, (char *) &regs->r_pc);
@ -130,10 +131,10 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
{ {
if (FP0_REGNUM >= 0) if (FP0_REGNUM >= 0)
{ {
memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)], memcpy (&&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
fpustruct->f_fpstatus.fps_regs, fpustruct->f_fpstatus.fps_regs,
sizeof fpustruct->f_fpstatus.fps_regs); sizeof fpustruct->f_fpstatus.fps_regs);
memcpy (&registers[REGISTER_BYTE (FPC_REGNUM)], memcpy (&&deprecated_registers[REGISTER_BYTE (FPC_REGNUM)],
&fpustruct->f_fpstatus.fps_control, &fpustruct->f_fpstatus.fps_control,
sizeof fpustruct->f_fpstatus - sizeof fpustruct->f_fpstatus -
sizeof fpustruct->f_fpstatus.fps_regs); sizeof fpustruct->f_fpstatus.fps_regs);

76
gdb/symm-nat.c
View file

@ -68,29 +68,29 @@ store_inferior_registers (int regno)
to the registers array to solve this properly. */ to the registers array to solve this properly. */
mptrace (XPT_RREGS, PIDGET (inferior_ptid), (PTRACE_ARG3_TYPE) & regs, 0); mptrace (XPT_RREGS, PIDGET (inferior_ptid), (PTRACE_ARG3_TYPE) & regs, 0);
regs.pr_eax = *(int *) &registers[REGISTER_BYTE (0)]; regs.pr_eax = *(int *) &deprecated_registers[REGISTER_BYTE (0)];
regs.pr_ebx = *(int *) &registers[REGISTER_BYTE (5)]; regs.pr_ebx = *(int *) &deprecated_registers[REGISTER_BYTE (5)];
regs.pr_ecx = *(int *) &registers[REGISTER_BYTE (2)]; regs.pr_ecx = *(int *) &deprecated_registers[REGISTER_BYTE (2)];
regs.pr_edx = *(int *) &registers[REGISTER_BYTE (1)]; regs.pr_edx = *(int *) &deprecated_registers[REGISTER_BYTE (1)];
regs.pr_esi = *(int *) &registers[REGISTER_BYTE (6)]; regs.pr_esi = *(int *) &deprecated_registers[REGISTER_BYTE (6)];
regs.pr_edi = *(int *) &registers[REGISTER_BYTE (7)]; regs.pr_edi = *(int *) &deprecated_registers[REGISTER_BYTE (7)];
regs.pr_esp = *(int *) &registers[REGISTER_BYTE (14)]; regs.pr_esp = *(int *) &deprecated_registers[REGISTER_BYTE (14)];
regs.pr_ebp = *(int *) &registers[REGISTER_BYTE (15)]; regs.pr_ebp = *(int *) &deprecated_registers[REGISTER_BYTE (15)];
regs.pr_eip = *(int *) &registers[REGISTER_BYTE (16)]; regs.pr_eip = *(int *) &deprecated_registers[REGISTER_BYTE (16)];
regs.pr_flags = *(int *) &registers[REGISTER_BYTE (17)]; regs.pr_flags = *(int *) &deprecated_registers[REGISTER_BYTE (17)];
for (i = 0; i < 31; i++) for (i = 0; i < 31; i++)
{ {
regs.pr_fpa.fpa_regs[i] = regs.pr_fpa.fpa_regs[i] =
*(int *) &registers[REGISTER_BYTE (FP1_REGNUM + i)]; *(int *) &deprecated_registers[REGISTER_BYTE (FP1_REGNUM + i)];
} }
memcpy (regs.pr_fpu.fpu_stack[0], &registers[REGISTER_BYTE (ST0_REGNUM)], 10); memcpy (regs.pr_fpu.fpu_stack[0], &deprecated_registers[REGISTER_BYTE (ST0_REGNUM)], 10);
memcpy (regs.pr_fpu.fpu_stack[1], &registers[REGISTER_BYTE (ST1_REGNUM)], 10); memcpy (regs.pr_fpu.fpu_stack[1], &deprecated_registers[REGISTER_BYTE (ST1_REGNUM)], 10);
memcpy (regs.pr_fpu.fpu_stack[2], &registers[REGISTER_BYTE (ST2_REGNUM)], 10); memcpy (regs.pr_fpu.fpu_stack[2], &deprecated_registers[REGISTER_BYTE (ST2_REGNUM)], 10);
memcpy (regs.pr_fpu.fpu_stack[3], &registers[REGISTER_BYTE (ST3_REGNUM)], 10); memcpy (regs.pr_fpu.fpu_stack[3], &deprecated_registers[REGISTER_BYTE (ST3_REGNUM)], 10);
memcpy (regs.pr_fpu.fpu_stack[4], &registers[REGISTER_BYTE (ST4_REGNUM)], 10); memcpy (regs.pr_fpu.fpu_stack[4], &deprecated_registers[REGISTER_BYTE (ST4_REGNUM)], 10);
memcpy (regs.pr_fpu.fpu_stack[5], &registers[REGISTER_BYTE (ST5_REGNUM)], 10); memcpy (regs.pr_fpu.fpu_stack[5], &deprecated_registers[REGISTER_BYTE (ST5_REGNUM)], 10);
memcpy (regs.pr_fpu.fpu_stack[6], &registers[REGISTER_BYTE (ST6_REGNUM)], 10); memcpy (regs.pr_fpu.fpu_stack[6], &deprecated_registers[REGISTER_BYTE (ST6_REGNUM)], 10);
memcpy (regs.pr_fpu.fpu_stack[7], &registers[REGISTER_BYTE (ST7_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); mptrace (XPT_WREGS, PIDGET (inferior_ptid), (PTRACE_ARG3_TYPE) & regs, 0);
} }
@ -103,29 +103,29 @@ fetch_inferior_registers (int regno)
deprecated_registers_fetched (); deprecated_registers_fetched ();
mptrace (XPT_RREGS, PIDGET (inferior_ptid), (PTRACE_ARG3_TYPE) & regs, 0); mptrace (XPT_RREGS, PIDGET (inferior_ptid), (PTRACE_ARG3_TYPE) & regs, 0);
*(int *) &registers[REGISTER_BYTE (EAX_REGNUM)] = regs.pr_eax; *(int *) &deprecated_registers[REGISTER_BYTE (EAX_REGNUM)] = regs.pr_eax;
*(int *) &registers[REGISTER_BYTE (EBX_REGNUM)] = regs.pr_ebx; *(int *) &rdeprecated_egisters[REGISTER_BYTE (EBX_REGNUM)] = regs.pr_ebx;
*(int *) &registers[REGISTER_BYTE (ECX_REGNUM)] = regs.pr_ecx; *(int *) &deprecated_registers[REGISTER_BYTE (ECX_REGNUM)] = regs.pr_ecx;
*(int *) &registers[REGISTER_BYTE (EDX_REGNUM)] = regs.pr_edx; *(int *) &deprecated_registers[REGISTER_BYTE (EDX_REGNUM)] = regs.pr_edx;
*(int *) &registers[REGISTER_BYTE (ESI_REGNUM)] = regs.pr_esi; *(int *) &deprecated_registers[REGISTER_BYTE (ESI_REGNUM)] = regs.pr_esi;
*(int *) &registers[REGISTER_BYTE (EDI_REGNUM)] = regs.pr_edi; *(int *) &deprecated_registers[REGISTER_BYTE (EDI_REGNUM)] = regs.pr_edi;
*(int *) &registers[REGISTER_BYTE (EBP_REGNUM)] = regs.pr_ebp; *(int *) &deprecated_registers[REGISTER_BYTE (EBP_REGNUM)] = regs.pr_ebp;
*(int *) &registers[REGISTER_BYTE (ESP_REGNUM)] = regs.pr_esp; *(int *) &deprecated_registers[REGISTER_BYTE (ESP_REGNUM)] = regs.pr_esp;
*(int *) &registers[REGISTER_BYTE (EIP_REGNUM)] = regs.pr_eip; *(int *) &deprecated_registers[REGISTER_BYTE (EIP_REGNUM)] = regs.pr_eip;
*(int *) &registers[REGISTER_BYTE (EFLAGS_REGNUM)] = regs.pr_flags; *(int *) &deprecated_registers[REGISTER_BYTE (EFLAGS_REGNUM)] = regs.pr_flags;
for (i = 0; i < FPA_NREGS; i++) for (i = 0; i < FPA_NREGS; i++)
{ {
*(int *) &registers[REGISTER_BYTE (FP1_REGNUM + i)] = *(int *) &deprecated_registers[REGISTER_BYTE (FP1_REGNUM + i)] =
regs.pr_fpa.fpa_regs[i]; regs.pr_fpa.fpa_regs[i];
} }
memcpy (&registers[REGISTER_BYTE (ST0_REGNUM)], regs.pr_fpu.fpu_stack[0], 10); memcpy (&deprecated_registers[REGISTER_BYTE (ST0_REGNUM)], regs.pr_fpu.fpu_stack[0], 10);
memcpy (&registers[REGISTER_BYTE (ST1_REGNUM)], regs.pr_fpu.fpu_stack[1], 10); memcpy (&deprecated_registers[REGISTER_BYTE (ST1_REGNUM)], regs.pr_fpu.fpu_stack[1], 10);
memcpy (&registers[REGISTER_BYTE (ST2_REGNUM)], regs.pr_fpu.fpu_stack[2], 10); memcpy (&deprecated_registers[REGISTER_BYTE (ST2_REGNUM)], regs.pr_fpu.fpu_stack[2], 10);
memcpy (&registers[REGISTER_BYTE (ST3_REGNUM)], regs.pr_fpu.fpu_stack[3], 10); memcpy (&deprecated_registers[REGISTER_BYTE (ST3_REGNUM)], regs.pr_fpu.fpu_stack[3], 10);
memcpy (&registers[REGISTER_BYTE (ST4_REGNUM)], regs.pr_fpu.fpu_stack[4], 10); memcpy (&deprecated_registers[REGISTER_BYTE (ST4_REGNUM)], regs.pr_fpu.fpu_stack[4], 10);
memcpy (&registers[REGISTER_BYTE (ST5_REGNUM)], regs.pr_fpu.fpu_stack[5], 10); memcpy (&deprecated_registers[REGISTER_BYTE (ST5_REGNUM)], regs.pr_fpu.fpu_stack[5], 10);
memcpy (&registers[REGISTER_BYTE (ST6_REGNUM)], regs.pr_fpu.fpu_stack[6], 10); memcpy (&deprecated_registers[REGISTER_BYTE (ST6_REGNUM)], regs.pr_fpu.fpu_stack[6], 10);
memcpy (&registers[REGISTER_BYTE (ST7_REGNUM)], regs.pr_fpu.fpu_stack[7], 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. */ /* FIXME: This should be merged with i387-tdep.c as well. */

2
gdb/v850ice.c
View file

@ -560,7 +560,7 @@ v850ice_store_registers (int regno)
return; return;
} }
regval = extract_unsigned_integer (&registers[REGISTER_BYTE (regno)], regval = extract_unsigned_integer (&deprecated_registers[REGISTER_BYTE (regno)],
REGISTER_RAW_SIZE (regno)); REGISTER_RAW_SIZE (regno));
strcpy (cmd, "reg "); strcpy (cmd, "reg ");
if (!convert_register (regno, &cmd[4])) if (!convert_register (regno, &cmd[4]))