yggdrasil/binutils-gdb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

2004-07-23 Andrew Cagney <cagney@gnu.org>

Browse Source 
Use regcache_raw_collect instead of regcache_collect.
	* regcache.h (regcache_collect): Delete declaration.
	* regcache.c (regcache_colect): Delete function.
	* win32-nat.c (do_child_store_inferior_registers): Update.
	* sol-thread.c (sol_thread_store_registers): Update.
	* shnbsd-tdep.c (shnbsd_fill_reg): Update.
	* rs6000-nat.c (store_register): Update.
	* remote.c (store_register_using_P, remote_store_registers): Update.
	* ppcnbsd-tdep.c (ppcnbsd_fill_reg): Update.
	* ppc-linux-nat.c (store_altivec_register, store_spe_register)
	(fill_vrregset, store_spe_registers, fill_gregset)
	(fill_gregset): Update.
	* nto-procfs.c (procfs_store_registers): Update.
	* mipsnbsd-tdep.c (mipsnbsd_fill_reg): Update.
	* mips-linux-tdep.c (fill_gregset, mips64_fill_gregset): Update.
	* m68klinux-nat.c (store_register, fill_gregset): Update.
	* m68k-tdep.c (fill_gregset): Update.
	* infptrace.c (store_register): Update.
	* i386-nto-tdep.c (i386nto_regset_fill): Update.
	* i386-linux-nat.c (store_register, fill_gregset): Update.
	* hppa-linux-nat.c (fill_gregset): Update.
	* go32-nat.c (store_register): Update.
	* armnbsd-nat.c (store_register, store_regs, store_fp_register)
	(store_fp_regs): Update.
	* arm-linux-nat.c (store_nwfpe_single, store_nwfpe_double)
	(store_nwfpe_extended, store_fpregister, store_fpregs)
	(store_register, store_regs, fill_gregset, fill_fpregset): Update.
	* alpha-tdep.c (alpha_fill_int_regs, alpha_fill_fp_regs): Update.
	* aix-thread.c (fill_gprs64, fill_fprs, fill_sprs64, fill_sprs32)
	(store_regs_user_thread, store_regs_kernel_thread): Update.
This commit is contained in:
Andrew Cagney 2004-07-24 01:00:21 +00:00
parent 49a13555d6
commit 822c97322c
25 changed files with 204 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
gdb/ChangeLog
View File

@ -1,3 +1,36 @@
2004-07-23 Andrew Cagney <cagney@gnu.org>
Use regcache_raw_collect instead of regcache_collect.
* regcache.h (regcache_collect): Delete declaration.
* regcache.c (regcache_colect): Delete function.
* win32-nat.c (do_child_store_inferior_registers): Update.
* sol-thread.c (sol_thread_store_registers): Update.
* shnbsd-tdep.c (shnbsd_fill_reg): Update.
* rs6000-nat.c (store_register): Update.
* remote.c (store_register_using_P, remote_store_registers): Update.
* ppcnbsd-tdep.c (ppcnbsd_fill_reg): Update.
* ppc-linux-nat.c (store_altivec_register, store_spe_register)
(fill_vrregset, store_spe_registers, fill_gregset)
(fill_gregset): Update.
* nto-procfs.c (procfs_store_registers): Update.
* mipsnbsd-tdep.c (mipsnbsd_fill_reg): Update.
* mips-linux-tdep.c (fill_gregset, mips64_fill_gregset): Update.
* m68klinux-nat.c (store_register, fill_gregset): Update.
* m68k-tdep.c (fill_gregset): Update.
* infptrace.c (store_register): Update.
* i386-nto-tdep.c (i386nto_regset_fill): Update.
* i386-linux-nat.c (store_register, fill_gregset): Update.
* hppa-linux-nat.c (fill_gregset): Update.
* go32-nat.c (store_register): Update.
* armnbsd-nat.c (store_register, store_regs, store_fp_register)
(store_fp_regs): Update.
* arm-linux-nat.c (store_nwfpe_single, store_nwfpe_double)
(store_nwfpe_extended, store_fpregister, store_fpregs)
(store_register, store_regs, fill_gregset, fill_fpregset): Update.
* alpha-tdep.c (alpha_fill_int_regs, alpha_fill_fp_regs): Update.
* aix-thread.c (fill_gprs64, fill_fprs, fill_sprs64, fill_sprs32)
(store_regs_user_thread, store_regs_kernel_thread): Update.
2004-07-24 Mark Kettenis <kettenis@gnu.org>
* dwarf2-frame.c (struct dwarf2_cie): Delete `addr_size' member.

45
gdb/aix-thread.c
View File

@ -1266,7 +1266,8 @@ fill_gprs64 (uint64_t *vals)
for (regno = 0; regno < ppc_num_gprs; regno++)
if (register_cached (tdep->ppc_gp0_regnum + regno))
regcache_collect (tdep->ppc_gp0_regnum + regno, vals + regno);
regcache_raw_collect (current_regcache, tdep->ppc_gp0_regnum + regno,
vals + regno);
}
static void
@ -1277,7 +1278,8 @@ fill_gprs32 (uint32_t *vals)
for (regno = 0; regno < ppc_num_gprs; regno++)
if (register_cached (tdep->ppc_gp0_regnum + regno))
regcache_collect (tdep->ppc_gp0_regnum + regno, vals + regno);
regcache_raw_collect (current_regcache, tdep->ppc_gp0_regnum + regno,
vals + regno);
}
/* Store the floating point registers into a double array. */
@ -1295,7 +1297,7 @@ fill_fprs (double *vals)
regno < tdep->ppc_fp0_regnum + ppc_num_fprs;
regno++)
if (register_cached (regno))
regcache_collect (regno, vals + regno);
regcache_raw_collect (current_regcache, regno, vals + regno);
}
/* Store the special registers into the specified 64-bit and 32-bit
@ -1316,20 +1318,20 @@ fill_sprs64 (uint64_t *iar, uint64_t *msr, uint32_t *cr,
gdb_assert (sizeof (*iar) == DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM));
if (register_cached (PC_REGNUM))
regcache_collect (PC_REGNUM, iar);
regcache_raw_collect (current_regcache, PC_REGNUM, iar);
if (register_cached (tdep->ppc_ps_regnum))
regcache_collect (tdep->ppc_ps_regnum, msr);
regcache_raw_collect (current_regcache, tdep->ppc_ps_regnum, msr);
if (register_cached (tdep->ppc_cr_regnum))
regcache_collect (tdep->ppc_cr_regnum, cr);
regcache_raw_collect (current_regcache, tdep->ppc_cr_regnum, cr);
if (register_cached (tdep->ppc_lr_regnum))
regcache_collect (tdep->ppc_lr_regnum, lr);
regcache_raw_collect (current_regcache, tdep->ppc_lr_regnum, lr);
if (register_cached (tdep->ppc_ctr_regnum))
regcache_collect (tdep->ppc_ctr_regnum, ctr);
regcache_raw_collect (current_regcache, tdep->ppc_ctr_regnum, ctr);
if (register_cached (tdep->ppc_xer_regnum))
regcache_collect (tdep->ppc_xer_regnum, xer);
regcache_raw_collect (current_regcache, tdep->ppc_xer_regnum, xer);
if (tdep->ppc_fpscr_regnum >= 0
&& register_cached (tdep->ppc_fpscr_regnum))
regcache_collect (tdep->ppc_fpscr_regnum, fpscr);
regcache_raw_collect (current_regcache, tdep->ppc_fpscr_regnum, fpscr);
}
static void
@ -1352,20 +1354,20 @@ fill_sprs32 (unsigned long *iar, unsigned long *msr, unsigned long *cr,
gdb_assert (sizeof (*iar) == DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM));
if (register_cached (PC_REGNUM))
regcache_collect (PC_REGNUM, iar);
regcache_raw_collect (current_regcache, PC_REGNUM, iar);
if (register_cached (tdep->ppc_ps_regnum))
regcache_collect (tdep->ppc_ps_regnum, msr);
regcache_raw_collect (current_regcache, tdep->ppc_ps_regnum, msr);
if (register_cached (tdep->ppc_cr_regnum))
regcache_collect (tdep->ppc_cr_regnum, cr);
regcache_raw_collect (current_regcache, tdep->ppc_cr_regnum, cr);
if (register_cached (tdep->ppc_lr_regnum))
regcache_collect (tdep->ppc_lr_regnum, lr);
regcache_raw_collect (current_regcache, tdep->ppc_lr_regnum, lr);
if (register_cached (tdep->ppc_ctr_regnum))
regcache_collect (tdep->ppc_ctr_regnum, ctr);
regcache_raw_collect (current_regcache, tdep->ppc_ctr_regnum, ctr);
if (register_cached (tdep->ppc_xer_regnum))
regcache_collect (tdep->ppc_xer_regnum, xer);
regcache_raw_collect (current_regcache, tdep->ppc_xer_regnum, xer);
if (tdep->ppc_fpscr_regnum >= 0
&& register_cached (tdep->ppc_fpscr_regnum))
regcache_collect (tdep->ppc_fpscr_regnum, fpscr);
regcache_raw_collect (current_regcache, tdep->ppc_fpscr_regnum, fpscr);
}
/* Store all registers into pthread PDTID, which doesn't have a kernel
@ -1402,12 +1404,14 @@ store_regs_user_thread (pthdb_pthread_t pdtid)
{
if (arch64)
{
regcache_collect (tdep->ppc_gp0_regnum + i, (void *) &int64);
regcache_raw_collect (current_regcache, tdep->ppc_gp0_regnum + i,
(void *) &int64);
ctx.gpr[i] = int64;
}
else
{
regcache_collect (tdep->ppc_gp0_regnum + i, (void *) &int32);
regcache_raw_collect (current_regcache, tdep->ppc_gp0_regnum + i,
(void *) &int32);
ctx.gpr[i] = int32;
}
}
@ -1539,7 +1543,8 @@ store_regs_kernel_thread (int regno, pthdb_tid_t tid)
if (tdep->ppc_mq_regnum >= 0)
if (register_cached (tdep->ppc_mq_regnum))
regcache_collect (tdep->ppc_mq_regnum, &sprs32.pt_mq);
regcache_raw_collect (current_regcache, tdep->ppc_mq_regnum,
&sprs32.pt_mq);
ptrace32 (PTT_WRITE_SPRS, tid, (int *) &sprs32, 0, NULL);
}

11
gdb/alpha-tdep.c
View File

@ -1322,13 +1322,13 @@ alpha_fill_int_regs (int regno, void *r0_r30, void *pc, void *unique)
for (i = 0; i < 31; ++i)
if (regno == i || regno == -1)
regcache_collect (i, (char *)r0_r30 + i*8);
regcache_raw_collect (current_regcache, i, (char *)r0_r30 + i*8);
if (regno == ALPHA_PC_REGNUM || regno == -1)
regcache_collect (ALPHA_PC_REGNUM, pc);
regcache_raw_collect (current_regcache, ALPHA_PC_REGNUM, pc);
if (unique && (regno == ALPHA_UNIQUE_REGNUM || regno == -1))
regcache_collect (ALPHA_UNIQUE_REGNUM, unique);
regcache_raw_collect (current_regcache, ALPHA_UNIQUE_REGNUM, unique);
}
void
@ -1352,10 +1352,11 @@ alpha_fill_fp_regs (int regno, void *f0_f30, void *fpcr)
for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; ++i)
if (regno == i || regno == -1)
regcache_collect (i, (char *)f0_f30 + (i - ALPHA_FP0_REGNUM) * 8);
regcache_raw_collect (current_regcache, i,
(char *)f0_f30 + (i - ALPHA_FP0_REGNUM) * 8);
if (regno == ALPHA_FPCR_REGNUM || regno == -1)
regcache_collect (ALPHA_FPCR_REGNUM, fpcr);
regcache_raw_collect (current_regcache, ALPHA_FPCR_REGNUM, fpcr);
}

34
gdb/arm-linux-nat.c
View File

@ -165,7 +165,8 @@ store_nwfpe_single (unsigned int fn, FPA11 *fpa11)
{
unsigned int mem[3];
regcache_collect (ARM_F0_REGNUM + fn, (char *) &mem[0]);
regcache_raw_collect (current_regcache, ARM_F0_REGNUM + fn,
(char *) &mem[0]);
fpa11->fpreg[fn].fSingle = mem[0];
fpa11->fType[fn] = typeSingle;
}
@ -175,7 +176,8 @@ store_nwfpe_double (unsigned int fn, FPA11 *fpa11)
{
unsigned int mem[3];
regcache_collect (ARM_F0_REGNUM + fn, (char *) &mem[0]);
regcache_raw_collect (current_regcache, ARM_F0_REGNUM + fn,
(char *) &mem[0]);
fpa11->fpreg[fn].fDouble[1] = mem[0];
fpa11->fpreg[fn].fDouble[0] = mem[1];
fpa11->fType[fn] = typeDouble;
@ -186,7 +188,8 @@ store_nwfpe_extended (unsigned int fn, FPA11 *fpa11)
{
unsigned int mem[3];
regcache_collect (ARM_F0_REGNUM + fn, (char *) &mem[0]);
regcache_raw_collect (current_regcache, ARM_F0_REGNUM + fn,
(char *) &mem[0]);
fpa11->fpreg[fn].fExtended[0] = mem[0]; /* sign & exponent */
fpa11->fpreg[fn].fExtended[2] = mem[1]; /* ls bits */
fpa11->fpreg[fn].fExtended[1] = mem[2]; /* ms bits */
@ -336,7 +339,7 @@ store_fpregister (int regno)
/* Store fpsr. */
if (ARM_FPS_REGNUM == regno && register_cached (ARM_FPS_REGNUM))
regcache_collect (ARM_FPS_REGNUM, (char *) &fp.fpsr);
regcache_raw_collect (current_regcache, ARM_FPS_REGNUM, (char *) &fp.fpsr);
/* Store the floating point register. */
if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM)
@ -374,7 +377,7 @@ store_fpregs (void)
/* Store fpsr. */
if (register_cached (ARM_FPS_REGNUM))
regcache_collect (ARM_FPS_REGNUM, (char *) &fp.fpsr);
regcache_raw_collect (current_regcache, ARM_FPS_REGNUM, (char *) &fp.fpsr);
/* Store the floating point registers. */
for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
@ -488,7 +491,7 @@ store_register (int regno)
}
if (regno >= ARM_A1_REGNUM && regno <= ARM_PC_REGNUM)
regcache_collect (regno, (char *) &regs[regno]);
regcache_raw_collect (current_regcache, regno, (char *) &regs[regno]);
ret = ptrace (PTRACE_SETREGS, tid, 0, &regs);
if (ret < 0)
@ -518,7 +521,7 @@ store_regs (void)
for (regno = ARM_A1_REGNUM; regno <= ARM_PC_REGNUM; regno++)
{
if (register_cached (regno))
regcache_collect (regno, (char *) &regs[regno]);
regcache_raw_collect (current_regcache, regno, (char *) &regs[regno]);
}
ret = ptrace (PTRACE_SETREGS, tid, 0, &regs);
@ -585,19 +588,21 @@ fill_gregset (gdb_gregset_t *gregsetp, int regno)
{
int regnum;
for (regnum = ARM_A1_REGNUM; regnum <= ARM_PC_REGNUM; regnum++)
regcache_collect (regnum, (char *) &(*gregsetp)[regnum]);
regcache_raw_collect (current_regcache, regnum,
(char *) &(*gregsetp)[regnum]);
}
else if (regno >= ARM_A1_REGNUM && regno <= ARM_PC_REGNUM)
regcache_collect (regno, (char *) &(*gregsetp)[regno]);
regcache_raw_collect (current_regcache, regno,
(char *) &(*gregsetp)[regno]);
if (ARM_PS_REGNUM == regno || -1 == regno)
{
if (arm_apcs_32)
regcache_collect (ARM_PS_REGNUM,
(char *) &(*gregsetp)[ARM_CPSR_REGNUM]);
regcache_raw_collect (current_regcache, ARM_PS_REGNUM,
(char *) &(*gregsetp)[ARM_CPSR_REGNUM]);
else
regcache_collect (ARM_PC_REGNUM,
(char *) &(*gregsetp)[ARM_PC_REGNUM]);
regcache_raw_collect (current_regcache, ARM_PC_REGNUM,
(char *) &(*gregsetp)[ARM_PC_REGNUM]);
}
}
@ -647,7 +652,8 @@ fill_fpregset (gdb_fpregset_t *fpregsetp, int regno)
/* Store fpsr. */
if (ARM_FPS_REGNUM == regno || -1 == regno)
regcache_collect (ARM_FPS_REGNUM, (char *) &fp->fpsr);
regcache_raw_collect (current_regcache, ARM_FPS_REGNUM,
(char *) &fp->fpsr);
}
/* Fill GDB's register array with the floating-point register values

57
gdb/armnbsd-nat.c
View File

@ -229,21 +229,25 @@ store_register (int regno)
switch (regno)
{
case ARM_SP_REGNUM:
regcache_collect (ARM_SP_REGNUM, (char *) &inferior_registers.r_sp);
regcache_raw_collect (current_regcache, ARM_SP_REGNUM,
(char *) &inferior_registers.r_sp);
break;
case ARM_LR_REGNUM:
regcache_collect (ARM_LR_REGNUM, (char *) &inferior_registers.r_lr);
regcache_raw_collect (current_regcache, ARM_LR_REGNUM,
(char *) &inferior_registers.r_lr);
break;
case ARM_PC_REGNUM:
if (arm_apcs_32)
regcache_collect (ARM_PC_REGNUM, (char *) &inferior_registers.r_pc);
regcache_raw_collect (current_regcache, ARM_PC_REGNUM,
(char *) &inferior_registers.r_pc);
else
{
unsigned pc_val;
regcache_collect (ARM_PC_REGNUM, (char *) &pc_val);
regcache_raw_collect (current_regcache, ARM_PC_REGNUM,
(char *) &pc_val);
pc_val = ADDR_BITS_REMOVE (pc_val);
inferior_registers.r_pc
@ -254,12 +258,14 @@ store_register (int regno)
case ARM_PS_REGNUM:
if (arm_apcs_32)
regcache_collect (ARM_PS_REGNUM, (char *) &inferior_registers.r_cpsr);
regcache_raw_collect (current_regcache, ARM_PS_REGNUM,
(char *) &inferior_registers.r_cpsr);
else
{
unsigned psr_val;
regcache_collect (ARM_PS_REGNUM, (char *) &psr_val);
regcache_raw_collect (current_regcache, ARM_PS_REGNUM,
(char *) &psr_val);
psr_val ^= ADDR_BITS_REMOVE (psr_val);
inferior_registers.r_pc = ADDR_BITS_REMOVE (inferior_registers.r_pc);
@ -268,7 +274,8 @@ store_register (int regno)
break;
default:
regcache_collect (regno, (char *) &inferior_registers.r[regno]);
regcache_raw_collect (current_regcache, regno,
(char *) &inferior_registers.r[regno]);
break;
}
@ -288,23 +295,30 @@ store_regs (void)
for (regno = ARM_A1_REGNUM; regno < ARM_SP_REGNUM; regno++)
regcache_collect (regno, (char *) &inferior_registers.r[regno]);
regcache_raw_collect (current_regcache, regno,
(char *) &inferior_registers.r[regno]);
regcache_collect (ARM_SP_REGNUM, (char *) &inferior_registers.r_sp);
regcache_collect (ARM_LR_REGNUM, (char *) &inferior_registers.r_lr);
regcache_raw_collect (current_regcache, ARM_SP_REGNUM,
(char *) &inferior_registers.r_sp);
regcache_raw_collect (current_regcache, ARM_LR_REGNUM,
(char *) &inferior_registers.r_lr);
if (arm_apcs_32)
{
regcache_collect (ARM_PC_REGNUM, (char *) &inferior_registers.r_pc);
regcache_collect (ARM_PS_REGNUM, (char *) &inferior_registers.r_cpsr);
regcache_raw_collect (current_regcache, ARM_PC_REGNUM,
(char *) &inferior_registers.r_pc);
regcache_raw_collect (current_regcache, ARM_PS_REGNUM,
(char *) &inferior_registers.r_cpsr);
}
else
{
unsigned pc_val;
unsigned psr_val;
regcache_collect (ARM_PC_REGNUM, (char *) &pc_val);
regcache_collect (ARM_PS_REGNUM, (char *) &psr_val);
regcache_raw_collect (current_regcache, ARM_PC_REGNUM,
(char *) &pc_val);
regcache_raw_collect (current_regcache, ARM_PS_REGNUM,
(char *) &psr_val);
pc_val = ADDR_BITS_REMOVE (pc_val);
psr_val ^= ADDR_BITS_REMOVE (psr_val);
@ -337,13 +351,13 @@ store_fp_register (int regno)
switch (regno)
{
case ARM_FPS_REGNUM:
regcache_collect (ARM_FPS_REGNUM,
(char *) &inferior_fp_registers.fpr_fpsr);
regcache_raw_collect (current_regcache, ARM_FPS_REGNUM,
(char *) &inferior_fp_registers.fpr_fpsr);
break;
default:
regcache_collect
(regno, (char *) &inferior_fp_registers.fpr[regno - ARM_F0_REGNUM]);
regcache_raw_collect (current_regcache, regno,
(char *) &inferior_fp_registers.fpr[regno - ARM_F0_REGNUM]);
break;
}
@ -363,10 +377,11 @@ store_fp_regs (void)
for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
regcache_collect
(regno, (char *) &inferior_fp_registers.fpr[regno - ARM_F0_REGNUM]);
regcache_raw_collect (current_regcache, regno,
(char *) &inferior_fp_registers.fpr[regno - ARM_F0_REGNUM]);
regcache_collect (ARM_FPS_REGNUM, (char *) &inferior_fp_registers.fpr_fpsr);
regcache_raw_collect (current_regcache, ARM_FPS_REGNUM,
(char *) &inferior_fp_registers.fpr_fpsr);
ret = ptrace (PT_SETFPREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) &inferior_fp_registers, 0);

3
gdb/go32-nat.c
View File

@ -492,7 +492,8 @@ static void
store_register (int regno)
{
if (regno < FP0_REGNUM)
regcache_collect (regno, (char *) &a_tss + regno_mapping[regno].tss_ofs);
regcache_raw_collect (current_regcache, regno,
(char *) &a_tss + regno_mapping[regno].tss_ofs);
else if (i386_fp_regnum_p (regno) || i386_fpc_regnum_p (regno))
i387_fill_fsave ((char *) &npx, regno);
else

4
gdb/hppa-linux-nat.c
View File

@ -330,7 +330,7 @@ fill_gregset (gdb_gregset_t *gregsetp, int regno)
if (regno == -1 || regno == mregno)
{
regcache_collect(mregno, &(*gregsetp)[i]);
regcache_raw_collect(current_regcache, mregno, &(*gregsetp)[i]);
}
}
}
@ -371,6 +371,6 @@ fill_fpregset (gdb_fpregset_t *fpregsetp, int regno)
char *to = (char *) &((*fpregsetp)[(i - HPPA_FP0_REGNUM) / 2]);
if ((i - HPPA_FP0_REGNUM) & 1)
to += 4;
regcache_collect (i, to);
regcache_raw_collect (current_regcache, i, to);
}
}

7
gdb/i386-linux-nat.c
View File

@ -215,7 +215,7 @@ store_register (int regno)
tid = PIDGET (inferior_ptid); /* Not a threaded program. */
errno = 0;
regcache_collect (regno, &val);
regcache_raw_collect (current_regcache, regno, &val);
ptrace (PTRACE_POKEUSER, tid, register_addr (regno, 0), val);
if (errno != 0)
error ("Couldn't write register %s (#%d): %s.", REGISTER_NAME (regno),
@ -255,11 +255,12 @@ fill_gregset (elf_gregset_t *gregsetp, int regno)
for (i = 0; i < I386_NUM_GREGS; i++)
if (regno == -1 || regno == i)
regcache_collect (i, regp + regmap[i]);
regcache_raw_collect (current_regcache, i, regp + regmap[i]);
if ((regno == -1 || regno == I386_LINUX_ORIG_EAX_REGNUM)
&& I386_LINUX_ORIG_EAX_REGNUM < NUM_REGS)
regcache_collect (I386_LINUX_ORIG_EAX_REGNUM, regp + ORIG_EAX);
regcache_raw_collect (current_regcache, I386_LINUX_ORIG_EAX_REGNUM,
regp + ORIG_EAX);
}
#ifdef HAVE_PTRACE_GETREGS

2
gdb/i386-nto-tdep.c
View File

@ -176,7 +176,7 @@ i386nto_regset_fill (int regset, char *data)
{
int offset = nto_reg_offset (regno);
if (offset != -1)
regcache_collect (regno, data + offset);
regcache_raw_collect (current_regcache, regno, data + offset);
}
}
else if (regset == NTO_REG_FLOAT)

2
gdb/infptrace.c
View File

@ -450,7 +450,7 @@ store_register (int regno)
regaddr = register_addr (regno, offset);
/* Put the contents of regno into a local buffer */
regcache_collect (regno, buf);
regcache_raw_collect (current_regcache, regno, buf);
/* Store the local buffer into the inferior a chunk at the time. */
for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))

18
gdb/m68k-tdep.c
View File

@ -978,12 +978,12 @@ fill_gregset (gregset_t *gregsetp, int regno)
for (regi = 0; regi < R_PC; regi++)
{
if (regno == -1 || regno == regi)
regcache_collect (regi, regp + regi);
regcache_raw_collect (current_regcache, regi, regp + regi);
}
if (regno == -1 || regno == PS_REGNUM)
regcache_collect (PS_REGNUM, regp + R_PS);
regcache_raw_collect (current_regcache, PS_REGNUM, regp + R_PS);
if (regno == -1 || regno == PC_REGNUM)
regcache_collect (PC_REGNUM, regp + R_PC);
regcache_raw_collect (current_regcache, PC_REGNUM, regp + R_PC);
}
#if defined (FP0_REGNUM)
@ -1024,14 +1024,18 @@ fill_fpregset (fpregset_t *fpregsetp, int regno)
for (regi = FP0_REGNUM; regi < M68K_FPC_REGNUM; regi++)
{
if (regno == -1 || regno == regi)
regcache_collect (regi, &fpregsetp->f_fpregs[regi - FP0_REGNUM][0]);
regcache_raw_collect (current_regcache, regi,
&fpregsetp->f_fpregs[regi - FP0_REGNUM][0]);
}
if (regno == -1 || regno == M68K_FPC_REGNUM)
regcache_collect (M68K_FPC_REGNUM, &fpregsetp->f_pcr);
regcache_raw_collect (current_regcache, M68K_FPC_REGNUM,
&fpregsetp->f_pcr);
if (regno == -1 || regno == M68K_FPS_REGNUM)
regcache_collect (M68K_FPS_REGNUM, &fpregsetp->f_psr);
regcache_raw_collect (current_regcache, M68K_FPS_REGNUM,
&fpregsetp->f_psr);
if (regno == -1 || regno == M68K_FPI_REGNUM)
regcache_collect (M68K_FPI_REGNUM, &fpregsetp->f_fpiaddr);
regcache_raw_collect (current_regcache, M68K_FPI_REGNUM,
&fpregsetp->f_fpiaddr);
}
#endif /* defined (FP0_REGNUM) */

10
gdb/m68klinux-nat.c
View File

@ -218,7 +218,7 @@ store_register (int regno)
regaddr = register_addr (regno, offset);
/* Put the contents of regno into a local buffer */
regcache_collect (regno, buf);
regcache_raw_collect (current_regcache, regno, buf);
/* Store the local buffer into the inferior a chunk at the time. */
for (i = 0; i < register_size (current_gdbarch, regno);
@ -298,7 +298,7 @@ fill_gregset (elf_gregset_t *gregsetp, int regno)
for (i = 0; i < NUM_GREGS; i++)
if (regno == -1 || regno == i)
regcache_collect (i, regp + regmap[i]);
regcache_raw_collect (current_regcache, i, regp + regmap[i]);
}
#ifdef HAVE_PTRACE_GETREGS
@ -388,12 +388,14 @@ fill_fpregset (elf_fpregset_t *fpregsetp, int regno)
/* Fill in the floating-point registers. */
for (i = FP0_REGNUM; i < FP0_REGNUM + 8; i++)
if (regno == -1 || regno == i)
regcache_collect (i, FPREG_ADDR (fpregsetp, i - FP0_REGNUM));
regcache_raw_collect (current_regcache, i,
FPREG_ADDR (fpregsetp, i - FP0_REGNUM));
/* Fill in the floating-point control registers. */
for (i = M68K_FPC_REGNUM; i <= M68K_FPI_REGNUM; i++)
if (regno == -1 || regno == i)
regcache_collect (i, (char *) &fpregsetp->fpcntl[i - M68K_FPC_REGNUM]);
regcache_raw_collect (current_regcache, i,
(char *) &fpregsetp->fpcntl[i - M68K_FPC_REGNUM]);
}
#ifdef HAVE_PTRACE_GETREGS

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

@ -161,7 +161,7 @@ fill_gregset (elf_gregset_t *gregsetp, int regno)
if (regno < 32)
{
dst = regp + regno + EF_REG0;
regcache_collect (regno, dst);
regcache_raw_collect (current_regcache, regno, dst);
return;
}
@ -183,7 +183,7 @@ fill_gregset (elf_gregset_t *gregsetp, int regno)
if (regaddr != -1)
{
dst = regp + regaddr;
regcache_collect (regno, dst);
regcache_raw_collect (current_regcache, regno, dst);
}
}
@ -440,7 +440,7 @@ mips64_fill_gregset (mips64_elf_gregset_t *gregsetp, int regno)
if (regno < 32)
{
dst = regp + regno + MIPS64_EF_REG0;
regcache_collect (regno, dst);
regcache_raw_collect (current_regcache, regno, dst);
return;
}
@ -462,7 +462,7 @@ mips64_fill_gregset (mips64_elf_gregset_t *gregsetp, int regno)
if (regaddr != -1)
{
dst = regp + regaddr;
regcache_collect (regno, dst);
regcache_raw_collect (current_regcache, regno, dst);
}
}

6
gdb/mipsnbsd-tdep.c
View File

@ -60,7 +60,8 @@ mipsnbsd_fill_reg (char *regs, int regno)
for (i = 0; i <= PC_REGNUM; i++)
if ((regno == i || regno == -1) && ! CANNOT_STORE_REGISTER (i))
regcache_collect (i, regs + (i * mips_isa_regsize (current_gdbarch)));
regcache_raw_collect (current_regcache, i,
regs + (i * mips_isa_regsize (current_gdbarch)));
}
void
@ -91,7 +92,8 @@ mipsnbsd_fill_fpreg (char *fpregs, int regno)
for (i = FP0_REGNUM; i <= mips_regnum (current_gdbarch)->fp_control_status;
i++)
if ((regno == i || regno == -1) && ! CANNOT_STORE_REGISTER (i))
regcache_collect (i, fpregs + ((i - FP0_REGNUM) * mips_isa_regsize (current_gdbarch)));
regcache_raw_collect (current_regcache, i,
fpregs + ((i - FP0_REGNUM) * mips_isa_regsize (current_gdbarch)));
}
static void

2
gdb/nto-procfs.c
View File

@ -1189,7 +1189,7 @@ procfs_store_registers (int regno)
if (len < 1)
return;
regcache_collect (regno, (char *) &reg + off);
regcache_raw_collect (current_regcache, regno, (char *) &reg + off);
err = devctl (ctl_fd, dev_set, &reg, regsize, 0);
if (err != EOK)

32
gdb/ppc-linux-nat.c
View File

@ -618,8 +618,8 @@ store_altivec_register (int tid, int regno)
if (regno == (tdep->ppc_vrsave_regnum - 1))
offset = vrregsize - DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum);
regcache_collect (regno,
regs + (regno - tdep->ppc_vr0_regnum) * vrregsize + offset);
regcache_raw_collect (current_regcache, regno,
regs + (regno - tdep->ppc_vr0_regnum) * vrregsize + offset);
ret = ptrace (PTRACE_SETVRREGS, tid, 0, &regs);
if (ret < 0)
@ -732,7 +732,7 @@ store_spe_register (int tid, int regno)
&& tdep->ppc_ev0_regnum <= regno && regno <= tdep->ppc_ev31_regnum)
{
char buf[MAX_REGISTER_SIZE];
regcache_collect (regno, buf);
regcache_raw_collect (current_regcache, regno, buf);
write_spliced_spe_reg (tid, regno, &evrregs, buf);
}
else if (tdep->ppc_acc_regnum >= 0
@ -740,14 +740,14 @@ store_spe_register (int tid, int regno)
{
gdb_assert (sizeof (evrregs.acc)
== register_size (current_gdbarch, regno));
regcache_collect (regno, &evrregs.acc);
regcache_raw_collect (current_regcache, regno, &evrregs.acc);
}
else if (tdep->ppc_spefscr_regnum >= 0
&& regno == tdep->ppc_spefscr_regnum)
{
gdb_assert (sizeof (evrregs.spefscr)
== register_size (current_gdbarch, regno));
regcache_collect (regno, &evrregs.spefscr);
regcache_raw_collect (current_regcache, regno, &evrregs.spefscr);
}
else
gdb_assert (0);
@ -843,10 +843,11 @@ fill_vrregset (gdb_vrregset_t *vrregsetp)
/* The last 2 registers of this set are only 32 bit long, not
128, but only VSCR is fetched as a 16 bytes quantity. */
if (i == (num_of_vrregs - 2))
regcache_collect (tdep->ppc_vr0_regnum + i,
*vrregsetp + i * vrregsize + offset);
regcache_raw_collect (current_regcache, tdep->ppc_vr0_regnum + i,
*vrregsetp + i * vrregsize + offset);
else
regcache_collect (tdep->ppc_vr0_regnum + i, *vrregsetp + i * vrregsize);
regcache_raw_collect (current_regcache, tdep->ppc_vr0_regnum + i,
*vrregsetp + i * vrregsize);
}
}
@ -889,16 +890,16 @@ store_spe_registers (int tid)
{
char buf[MAX_REGISTER_SIZE];
regcache_collect (tdep->ppc_ev0_regnum + i, buf);
regcache_raw_collect (current_regcache, tdep->ppc_ev0_regnum + i, buf);
write_spliced_spe_reg (tid, tdep->ppc_ev0_regnum + i, &evrregs, buf);
}
gdb_assert (sizeof (evrregs.acc)
== register_size (current_gdbarch, tdep->ppc_acc_regnum));
regcache_collect (tdep->ppc_acc_regnum, &evrregs.acc);
regcache_raw_collect (current_regcache, tdep->ppc_acc_regnum, &evrregs.acc);
gdb_assert (sizeof (evrregs.spefscr)
== register_size (current_gdbarch, tdep->ppc_spefscr_regnum));
regcache_collect (tdep->ppc_acc_regnum, &evrregs.spefscr);
regcache_raw_collect (current_regcache, tdep->ppc_acc_regnum, &evrregs.spefscr);
set_spe_registers (tid, &evrregs);
}
@ -999,9 +1000,11 @@ fill_gregset (gdb_gregset_t *gregsetp, int regno)
if ((regno == -1) || regno == tdep->ppc_lr_regnum)
right_fill_reg (tdep->ppc_lr_regnum, regp + PT_LNK);
if ((regno == -1) || regno == tdep->ppc_cr_regnum)
regcache_collect (tdep->ppc_cr_regnum, regp + PT_CCR);
regcache_raw_collect (current_regcache, tdep->ppc_cr_regnum,
regp + PT_CCR);
if ((regno == -1) || regno == tdep->ppc_xer_regnum)
regcache_collect (tdep->ppc_xer_regnum, regp + PT_XER);
regcache_raw_collect (current_regcache, tdep->ppc_xer_regnum,
regp + PT_XER);
if ((regno == -1) || regno == tdep->ppc_ctr_regnum)
right_fill_reg (tdep->ppc_ctr_regnum, regp + PT_CTR);
#ifdef PT_MQ
@ -1036,7 +1039,8 @@ fill_fpregset (gdb_fpregset_t *fpregsetp, int regno)
for (regi = 0; regi < ppc_num_fprs; regi++)
{
if ((regno == -1) || (regno == tdep->ppc_fp0_regnum + regi))
regcache_collect (tdep->ppc_fp0_regnum + regi, fpp + 8 * regi);
regcache_raw_collect (current_regcache, tdep->ppc_fp0_regnum + regi,
fpp + 8 * regi);
}
if (regno == -1 || regno == tdep->ppc_fpscr_regnum)
right_fill_reg (tdep->ppc_fpscr_regnum, (fpp + 8 * 32));

25
gdb/ppcnbsd-tdep.c
View File

@ -92,24 +92,28 @@ ppcnbsd_fill_reg (char *regs, int regno)
for (i = 0; i < ppc_num_gprs; i++)
{
if (regno == tdep->ppc_gp0_regnum + i || regno == -1)
regcache_collect (tdep->ppc_gp0_regnum + i,
regs + REG_FIXREG_OFFSET (i));
regcache_raw_collect (current_regcache, tdep->ppc_gp0_regnum + i,
regs + REG_FIXREG_OFFSET (i));
}
if (regno == tdep->ppc_lr_regnum || regno == -1)
regcache_collect (tdep->ppc_lr_regnum, regs + REG_LR_OFFSET);
regcache_raw_collect (current_regcache, tdep->ppc_lr_regnum,
regs + REG_LR_OFFSET);
if (regno == tdep->ppc_cr_regnum || regno == -1)
regcache_collect (tdep->ppc_cr_regnum, regs + REG_CR_OFFSET);
regcache_raw_collect (current_regcache, tdep->ppc_cr_regnum,
regs + REG_CR_OFFSET);
if (regno == tdep->ppc_xer_regnum || regno == -1)
regcache_collect (tdep->ppc_xer_regnum, regs + REG_XER_OFFSET);
regcache_raw_collect (current_regcache, tdep->ppc_xer_regnum,
regs + REG_XER_OFFSET);
if (regno == tdep->ppc_ctr_regnum || regno == -1)
regcache_collect (tdep->ppc_ctr_regnum, regs + REG_CTR_OFFSET);
regcache_raw_collect (current_regcache, tdep->ppc_ctr_regnum,
regs + REG_CTR_OFFSET);
if (regno == PC_REGNUM || regno == -1)
regcache_collect (PC_REGNUM, regs + REG_PC_OFFSET);
regcache_raw_collect (current_regcache, PC_REGNUM, regs + REG_PC_OFFSET);
}
void
@ -163,12 +167,13 @@ ppcnbsd_fill_fpreg (char *fpregs, int regno)
for (i = 0; i < ppc_num_fprs; i++)
{
if (regno == tdep->ppc_fp0_regnum + i || regno == -1)
regcache_collect (tdep->ppc_fp0_regnum + i,
fpregs + FPREG_FPR_OFFSET (i));
regcache_raw_collect (current_regcache, tdep->ppc_fp0_regnum + i,
fpregs + FPREG_FPR_OFFSET (i));
}
if (regno == tdep->ppc_fpscr_regnum || regno == -1)
regcache_collect (tdep->ppc_fpscr_regnum, fpregs + FPREG_FPSCR_OFFSET);
regcache_raw_collect (current_regcache, tdep->ppc_fpscr_regnum,
fpregs + FPREG_FPSCR_OFFSET);
}
static void

6
gdb/regcache.c
View File

@ -1218,12 +1218,6 @@ write_register_pid (int regnum, CORE_ADDR val, ptid_t ptid)
inferior_ptid = save_ptid;
}
void
regcache_collect (int regnum, void *buf)
{
regcache_raw_collect (current_regcache, regnum, buf);
}
/* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
void

1
gdb/regcache.h
View File

@ -96,7 +96,6 @@ void regcache_cooked_write_part (struct regcache *regcache, int regnum,
target. These functions are called by the target in response to a
target_fetch_registers() or target_store_registers(). */
extern void regcache_collect (int regnum, void *buf);
extern void regcache_raw_supply (struct regcache *regcache,
int regnum, const void *buf);
extern void regcache_raw_collect (const struct regcache *regcache,

4
gdb/remote.c
View File

@ -3297,7 +3297,7 @@ store_register_using_P (int regnum)
sprintf (buf, "P%s=", phex_nz (reg->pnum, 0));
p = buf + strlen (buf);
regcache_collect (reg->regnum, regp);
regcache_raw_collect (current_regcache, reg->regnum, regp);
bin2hex (regp, p, DEPRECATED_REGISTER_RAW_SIZE (reg->regnum));
remote_send (buf, rs->remote_packet_size);
@ -3358,7 +3358,7 @@ remote_store_registers (int regnum)
{
struct packet_reg *r = &rs->regs[i];
if (r->in_g_packet)
regcache_collect (r->regnum, regs + r->offset);
regcache_raw_collect (current_regcache, r->regnum, regs + r->offset);
}
}

2
gdb/rs6000-nat.c
View File

@ -283,7 +283,7 @@ store_register (int regno)
int nr, isfloat;
/* Fetch the register's value from the register cache. */
regcache_collect (regno, addr);
regcache_raw_collect (current_regcache, regno, addr);
/* -1 can be a successful return value, so infer errors from errno. */
errno = 0;

13
gdb/shnbsd-tdep.c
View File

@ -90,25 +90,26 @@ shnbsd_fill_reg (char *regs, int regno)
int i;
if (regno == PC_REGNUM || regno == -1)
regcache_collect (PC_REGNUM, regs + (0 * 4));
regcache_raw_collect (current_regcache, PC_REGNUM, regs + (0 * 4));
if (regno == SR_REGNUM || regno == -1)
regcache_collect (SR_REGNUM, regs + (1 * 4));
regcache_raw_collect (current_regcache, SR_REGNUM, regs + (1 * 4));
if (regno == PR_REGNUM || regno == -1)
regcache_collect (PR_REGNUM, regs + (2 * 4));
regcache_raw_collect (current_regcache, PR_REGNUM, regs + (2 * 4));
if (regno == MACH_REGNUM || regno == -1)
regcache_collect (MACH_REGNUM, regs + (3 * 4));
regcache_raw_collect (current_regcache, MACH_REGNUM, regs + (3 * 4));
if (regno == MACL_REGNUM || regno == -1)
regcache_collect (MACL_REGNUM, regs + (4 * 4));
regcache_raw_collect (current_regcache, MACL_REGNUM, regs + (4 * 4));
if ((regno >= R0_REGNUM && regno <= (R0_REGNUM + 15)) || regno == -1)
{
for (i = R0_REGNUM; i <= (R0_REGNUM + 15); i++)
if (regno == i || regno == -1)
regcache_collect (i, regs + regmap[i - R0_REGNUM]);
regcache_raw_collect (current_regcache, i,
regs + regmap[i - R0_REGNUM]);
}
}

2
gdb/sol-thread.c
View File

@ -585,7 +585,7 @@ sol_thread_store_registers (int regnum)
char old_value[MAX_REGISTER_SIZE];
/* Save new register value. */
regcache_collect (regnum, old_value);
regcache_raw_collect (current_regcache, regnum, old_value);
val = p_td_thr_getgregs (&thandle, gregset);
if (val != TD_OK)

3
gdb/win32-nat.c
View File

@ -392,7 +392,8 @@ do_child_store_inferior_registers (int r)
if (!current_thread)
/* Windows sometimes uses a non-existent thread id in its events */;
else if (r >= 0)
regcache_collect (r, ((char *) &current_thread->context) + mappings[r]);
regcache_raw_collect (current_regcache, r,
((char *) &current_thread->context) + mappings[r]);
else
{
for (r = 0; r < NUM_REGS; r++)

3
gdb/windows-nat.c
View File

@ -392,7 +392,8 @@ do_child_store_inferior_registers (int r)
if (!current_thread)
/* Windows sometimes uses a non-existent thread id in its events */;
else if (r >= 0)
regcache_collect (r, ((char *) &current_thread->context) + mappings[r]);
regcache_raw_collect (current_regcache, r,
((char *) &current_thread->context) + mappings[r]);
else
{
for (r = 0; r < NUM_REGS; r++)