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

* target.h (struct regcache): Add forward declaration.

Browse source 
(struct target_ops): Add REGCACHE parameter to to_fetch_registers
	and to_store_registers target operations.
	(target_fetch_registers, target_store_registers): Update.

	* regcache.c (regcache_raw_read): Replace register_cached by
	regcache_valid_p.  Pass regcache to target_fetch_registers.
	(regcache_raw_write): Pass regcache to target_store_registers.

	* arm-linux-nat.c (store_fpregister, store_fpregs, store_register,
	store_regs, store_wmmx_regs): Replace register_cached by
	regcache_valid_p.

	* bsd-kvm.c (bsd_kvm_open, bsd_kvm_proc_cmd): Pass current_regcache
	to target_fetch_registers calls.
	* corelow.c (core_open): Likewise.
	* linux-nat.c (linux_nat_corefile_thread_callback): Likewise.
	* proc-service.c (ps_lgetregs, ps_lsetregs, ps_lgetfpregs,
	ps_lsetfpregs): Likewise.
	* sol-thread.c (ps_lgetregs, ps_lsetregs, ps_lgetfpregs,
	ps_lsetfpregs): Likewise.
	* win32-nat.c (win32_resume): Likewise.
	* ia64-tdep.c (ia64_store_return_value): Pass current_regcache
	to target_store_registers call.
	* rs6000-tdep.c (rs6000_push_dummy_call): Likewise.

	* inferior.h (store_inferior_registers): Update prototype.
	(fetch_inferior_registers): Likewise.
	* gnu-nat.c (gnu_store_registers, gnu_fetch_registers): Likewise.
	* mips-linux-nat.c (super_fetch_registers, super_store_registers):
	Update function pointer signatures.

	* aix-thread.c (aix_thread_fetch_registers): Add REGCACHE parameter,
	use it instead of current_regcache, update calls.
	(aix_thread_store_registers): Likewise.
	* alphabsd-nat.c (alphabsd_fetch_inferior_registers): Likewise.
	(alphabsd_store_inferior_registers): Likewise.
	* amd64bsd-nat.c (amd64bsd_fetch_inferior_registers): Likewise.
	(amd64bsd_store_inferior_registers): Likewise.
	* amd64-linux-nat.c (amd64_linux_fetch_inferior_registers): Likewise.
	(amd64_linux_store_inferior_registers): Likewise.
	* arm-linux-nat.c (fetch_fpregister, fetch_fpregs, store_fpregister,
	store_fpregs, fetch_register, fetch_regs, store_register, store_regs,
	fetch_wmmx_regs, store_wmmx_regs): Likewise.
	(arm_linux_fetch_inferior_registers): Likewise.
	(arm_linux_store_inferior_registers): Likewise.
	* armnbsd-nat.c (fetch_register, fetch_regs, fetch_fp_register,
	fetch_fp_regs, armnbsd_fetch_registers): Likewise.
	(store_register, store_regs, store_fp_register, store_fp_regs,
	armnbsd_store_registers): Likewise.
	* bsd-kvm.c (bsd_kvm_fetch_pcb, bsd_kvm_fetch_registers): Likewise.
	* bsd-uthread.c (bsd_uthread_fetch_registers): Likewise.
	(bsd_uthread_store_registers): Likewise.
	* corelow.c (get_core_registers): Likewise.
	* go32-nat.c (fetch_register, go32_fetch_registers, store_register,
	go32_store_registers): Likewise.
	* hppabsd-nat.c (hppabsd_fetch_registers): Likewise.
	(hppabsd_store_registers): Likewise.
	* hppa-hpux-nat.c (hppa_hpux_fetch_register): Likewise.
	(hppa_hpux_fetch_inferior_registers): Likewise.
	(hppa_hpux_store_register): Likewise.
	(hppa_hpux_store_inferior_registers): Likewise.
	* hppa-linux-nat.c (fetch_register, store_register): Likewise.
	(hppa_linux_fetch_inferior_registers): Likewise.
	(hppa_linux_store_inferior_registers): Likewise.
	* hpux-thread.c (hpux_thread_fetch_registers): Likewise.
	(hpux_thread_store_registers): Likewise.
	* i386bsd-nat.c (i386bsd_fetch_inferior_registers): Likewise.
	(i386bsd_store_inferior_registers): Likewise.
	* i386gnu-nat.c (fetch_fpregs, gnu_fetch_registers, store_fpregs,
	gnu_store_registers): Likewise.
	* i386-linux-nat.c (fetch_register, store_register, fetch_regs,
	store_regs, fetch_fpregs, store_fpregs, fetch_fpxregs, store_fpxregs):
	Likewise.
	(i386_linux_fetch_inferior_registers): Likewise.
	(i386_linux_store_inferior_registers): Likewise.
	* ia64-linux-nat.c (ia64_linux_fetch_register): Likewise.
	(ia64_linux_fetch_registers): Likewise.
	(ia64_linux_store_register): Likewise.
	(ia64_linux_store_registers): Likewise.
	* inf-child.c (inf_child_fetch_inferior_registers): Likewise.
	(inf_child_store_inferior_registers): Likewise.
	* inf-ptrace.c (inf_ptrace_fetch_register): Likewise.
	(inf_ptrace_fetch_registers): Likewise.
	(inf_ptrace_store_register): Likewise.
	(inf_ptrace_store_registers): Likewise.
	* infptrace.c (fetch_register, store_register): Likewise.
	(fetch_inferior_registers, store_inferior_registers): Likewise.
	* m32r-linux-nat.c (fetch_regs, store_regs): Likewise.
	(m32r_linux_fetch_inferior_registers): Likewise.
	(m32r_linux_store_inferior_registers): Likewise.
	* m68kbsd-nat.c (m68kbsd_fetch_inferior_registers): Likewise.
	(m68kbsd_store_inferior_registers): Likewise.
	* m68klinux-nat.c (fetch_register, old_fetch_inferior_registers,
	store_register, old_store_inferior_registers, fetch_regs, store_regs,
	fetch_fpregs, store_fpregs): Likewise.
	(m68k_linux_fetch_inferior_registers): Likewise.
	(m68k_linux_store_inferior_registers): Likewise.
	* m88kbsd-nat.c (m88kbsd_fetch_inferior_registers): Likewise.
	(m88kbsd_store_inferior_registers): Likewise.
	* mips64obsd-nat.c (mips64obsd_fetch_inferior_registers): Likewise.
	(mips64obsd_store_inferior_registers): Likewise.
	* mips-linux-nat.c (mips64_linux_regsets_fetch_registers): Likewise.
	(mips64_linux_regsets_store_registers): Likewise.
	(mips64_linux_fetch_registers): Likewise.
	(mips64_linux_store_registers): Likewise.
	* mipsnbsd-nat.c (mipsnbsd_fetch_inferior_registers): Likewise.
	(mipsnbsd_store_inferior_registers): Likewise.
	* monitor.c (monitor_fetch_register, monitor_store_register): Likewise.
	(monitor_fetch_registers, monitor_store_registers): Likewise.
	* nto-procfs.c (procfs_fetch_registers): Likewise.
	(procfs_store_registers): Likewise.
	* ppc-linux-nat.c (fetch_altivec_register, fetch_spe_register,
	fetch_register, supply_vrregset, fetch_altivec_registers,
	fetch_ppc_registers, ppc_linux_fetch_inferior_registers): Likewise.
	(store_altivec_register, store_spe_register, store_register,
	fill_vrregset, store_altivec_registers, store_ppc_registers,
	ppc_linux_store_inferior_registers): Likewise.
	* ppcnbsd-nat.c (ppcnbsd_fetch_inferior_registers): Likewise.
	(ppcnbsd_store_inferior_registers): Likewise.
	* ppcobsd-nat.c (ppcobsd_fetch_registers): Likewise.
	(ppcobsd_store_registers): Likewise.
	* procfs.c (procfs_fetch_registers, procfs_store_registers): Likewise.
	* remote.c (fetch_register_using_p, process_g_packet,
	fetch_registers_using_g, remote_fetch_registers): Likewise.
	(store_register_using_P, store_registers_using_G,
	remote_store_registers): Likewise.
	* remote-m32r-sdi.c (m32r_fetch_registers, m32r_fetch_register,
	m32r_store_register, m32r_store_register): Likewise.
	* remote-mips.c (mips_fetch_registers, mips_store_registers): Likewise.
	* remote-sim.c (gdbsim_fetch_register): Likewise.
	(gdbsim_store_register): Likewise.
	* rs6000-nat.c (fetch_register, store_register): Likewise.
	(rs6000_fetch_inferior_registers): Likewise.
	(rs6000_store_inferior_registers): Likewise.
	* s390-nat.c (fetch_regs, store_regs): Likewise.
	(fetch_fpregs, store_fpregs): Likewise.
	(s390_linux_fetch_inferior_registers): Likewise.
	(s390_linux_store_inferior_registers): Likewise.
	* shnbsd-nat.c (shnbsd_fetch_inferior_registers): Likewise.
	(shnbsd_store_inferior_registers): Likewise.
	* sol-thread.c (sol_thread_fetch_registers): Likewise.
	(sol_thread_store_registers): Likewise.
	* sparc-nat.c (fetch_inferior_registers): Likewise.
	(store_inferior_registers): Likewise.
	* spu-linux-nat.c (spu_fetch_inferior_registers): Likewise.
	(spu_store_inferior_registers): Likewise.
	* target.c (debug_print_register): Likewise.
	(debug_to_fetch_registers, debug_to_store_registers): Likewise.
	* vaxbsd-nat.c (vaxbsd_fetch_inferior_registers): Likewise.
	(vaxbsd_store_inferior_registers): Likewise.
	* win32-nat.c (do_win32_fetch_inferior_registers): Likewise.
	(win32_fetch_inferior_registers): Likewise.
	(win32_store_inferior_registers): Likewise.
This commit is contained in:
Ulrich Weigand 2007-05-06 14:34:38 +00:00
parent 9eefc95f4b
commit 56be38147c
57 changed files with 855 additions and 700 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

157
gdb/ChangeLog
View file

@ -1,3 +1,160 @@
2007-05-06 Ulrich Weigand <uweigand@de.ibm.com>
* target.h (struct regcache): Add forward declaration.
(struct target_ops): Add REGCACHE parameter to to_fetch_registers
and to_store_registers target operations.
(target_fetch_registers, target_store_registers): Update.
* regcache.c (regcache_raw_read): Replace register_cached by
regcache_valid_p. Pass regcache to target_fetch_registers.
(regcache_raw_write): Pass regcache to target_store_registers.
* arm-linux-nat.c (store_fpregister, store_fpregs, store_register,
store_regs, store_wmmx_regs): Replace register_cached by
regcache_valid_p.
* bsd-kvm.c (bsd_kvm_open, bsd_kvm_proc_cmd): Pass current_regcache
to target_fetch_registers calls.
* corelow.c (core_open): Likewise.
* linux-nat.c (linux_nat_corefile_thread_callback): Likewise.
* proc-service.c (ps_lgetregs, ps_lsetregs, ps_lgetfpregs,
ps_lsetfpregs): Likewise.
* sol-thread.c (ps_lgetregs, ps_lsetregs, ps_lgetfpregs,
ps_lsetfpregs): Likewise.
* win32-nat.c (win32_resume): Likewise.
* ia64-tdep.c (ia64_store_return_value): Pass current_regcache
to target_store_registers call.
* rs6000-tdep.c (rs6000_push_dummy_call): Likewise.
* inferior.h (store_inferior_registers): Update prototype.
(fetch_inferior_registers): Likewise.
* gnu-nat.c (gnu_store_registers, gnu_fetch_registers): Likewise.
* mips-linux-nat.c (super_fetch_registers, super_store_registers):
Update function pointer signatures.
* aix-thread.c (aix_thread_fetch_registers): Add REGCACHE parameter,
use it instead of current_regcache, update calls.
(aix_thread_store_registers): Likewise.
* alphabsd-nat.c (alphabsd_fetch_inferior_registers): Likewise.
(alphabsd_store_inferior_registers): Likewise.
* amd64bsd-nat.c (amd64bsd_fetch_inferior_registers): Likewise.
(amd64bsd_store_inferior_registers): Likewise.
* amd64-linux-nat.c (amd64_linux_fetch_inferior_registers): Likewise.
(amd64_linux_store_inferior_registers): Likewise.
* arm-linux-nat.c (fetch_fpregister, fetch_fpregs, store_fpregister,
store_fpregs, fetch_register, fetch_regs, store_register, store_regs,
fetch_wmmx_regs, store_wmmx_regs): Likewise.
(arm_linux_fetch_inferior_registers): Likewise.
(arm_linux_store_inferior_registers): Likewise.
* armnbsd-nat.c (fetch_register, fetch_regs, fetch_fp_register,
fetch_fp_regs, armnbsd_fetch_registers): Likewise.
(store_register, store_regs, store_fp_register, store_fp_regs,
armnbsd_store_registers): Likewise.
* bsd-kvm.c (bsd_kvm_fetch_pcb, bsd_kvm_fetch_registers): Likewise.
* bsd-uthread.c (bsd_uthread_fetch_registers): Likewise.
(bsd_uthread_store_registers): Likewise.
* corelow.c (get_core_registers): Likewise.
* go32-nat.c (fetch_register, go32_fetch_registers, store_register,
go32_store_registers): Likewise.
* hppabsd-nat.c (hppabsd_fetch_registers): Likewise.
(hppabsd_store_registers): Likewise.
* hppa-hpux-nat.c (hppa_hpux_fetch_register): Likewise.
(hppa_hpux_fetch_inferior_registers): Likewise.
(hppa_hpux_store_register): Likewise.
(hppa_hpux_store_inferior_registers): Likewise.
* hppa-linux-nat.c (fetch_register, store_register): Likewise.
(hppa_linux_fetch_inferior_registers): Likewise.
(hppa_linux_store_inferior_registers): Likewise.
* hpux-thread.c (hpux_thread_fetch_registers): Likewise.
(hpux_thread_store_registers): Likewise.
* i386bsd-nat.c (i386bsd_fetch_inferior_registers): Likewise.
(i386bsd_store_inferior_registers): Likewise.
* i386gnu-nat.c (fetch_fpregs, gnu_fetch_registers, store_fpregs,
gnu_store_registers): Likewise.
* i386-linux-nat.c (fetch_register, store_register, fetch_regs,
store_regs, fetch_fpregs, store_fpregs, fetch_fpxregs, store_fpxregs):
Likewise.
(i386_linux_fetch_inferior_registers): Likewise.
(i386_linux_store_inferior_registers): Likewise.
* ia64-linux-nat.c (ia64_linux_fetch_register): Likewise.
(ia64_linux_fetch_registers): Likewise.
(ia64_linux_store_register): Likewise.
(ia64_linux_store_registers): Likewise.
* inf-child.c (inf_child_fetch_inferior_registers): Likewise.
(inf_child_store_inferior_registers): Likewise.
* inf-ptrace.c (inf_ptrace_fetch_register): Likewise.
(inf_ptrace_fetch_registers): Likewise.
(inf_ptrace_store_register): Likewise.
(inf_ptrace_store_registers): Likewise.
* infptrace.c (fetch_register, store_register): Likewise.
(fetch_inferior_registers, store_inferior_registers): Likewise.
* m32r-linux-nat.c (fetch_regs, store_regs): Likewise.
(m32r_linux_fetch_inferior_registers): Likewise.
(m32r_linux_store_inferior_registers): Likewise.
* m68kbsd-nat.c (m68kbsd_fetch_inferior_registers): Likewise.
(m68kbsd_store_inferior_registers): Likewise.
* m68klinux-nat.c (fetch_register, old_fetch_inferior_registers,
store_register, old_store_inferior_registers, fetch_regs, store_regs,
fetch_fpregs, store_fpregs): Likewise.
(m68k_linux_fetch_inferior_registers): Likewise.
(m68k_linux_store_inferior_registers): Likewise.
* m88kbsd-nat.c (m88kbsd_fetch_inferior_registers): Likewise.
(m88kbsd_store_inferior_registers): Likewise.
* mips64obsd-nat.c (mips64obsd_fetch_inferior_registers): Likewise.
(mips64obsd_store_inferior_registers): Likewise.
* mips-linux-nat.c (mips64_linux_regsets_fetch_registers): Likewise.
(mips64_linux_regsets_store_registers): Likewise.
(mips64_linux_fetch_registers): Likewise.
(mips64_linux_store_registers): Likewise.
* mipsnbsd-nat.c (mipsnbsd_fetch_inferior_registers): Likewise.
(mipsnbsd_store_inferior_registers): Likewise.
* monitor.c (monitor_fetch_register, monitor_store_register): Likewise.
(monitor_fetch_registers, monitor_store_registers): Likewise.
* nto-procfs.c (procfs_fetch_registers): Likewise.
(procfs_store_registers): Likewise.
* ppc-linux-nat.c (fetch_altivec_register, fetch_spe_register,
fetch_register, supply_vrregset, fetch_altivec_registers,
fetch_ppc_registers, ppc_linux_fetch_inferior_registers): Likewise.
(store_altivec_register, store_spe_register, store_register,
fill_vrregset, store_altivec_registers, store_ppc_registers,
ppc_linux_store_inferior_registers): Likewise.
* ppcnbsd-nat.c (ppcnbsd_fetch_inferior_registers): Likewise.
(ppcnbsd_store_inferior_registers): Likewise.
* ppcobsd-nat.c (ppcobsd_fetch_registers): Likewise.
(ppcobsd_store_registers): Likewise.
* procfs.c (procfs_fetch_registers, procfs_store_registers): Likewise.
* remote.c (fetch_register_using_p, process_g_packet,
fetch_registers_using_g, remote_fetch_registers): Likewise.
(store_register_using_P, store_registers_using_G,
remote_store_registers): Likewise.
* remote-m32r-sdi.c (m32r_fetch_registers, m32r_fetch_register,
m32r_store_register, m32r_store_register): Likewise.
* remote-mips.c (mips_fetch_registers, mips_store_registers): Likewise.
* remote-sim.c (gdbsim_fetch_register): Likewise.
(gdbsim_store_register): Likewise.
* rs6000-nat.c (fetch_register, store_register): Likewise.
(rs6000_fetch_inferior_registers): Likewise.
(rs6000_store_inferior_registers): Likewise.
* s390-nat.c (fetch_regs, store_regs): Likewise.
(fetch_fpregs, store_fpregs): Likewise.
(s390_linux_fetch_inferior_registers): Likewise.
(s390_linux_store_inferior_registers): Likewise.
* shnbsd-nat.c (shnbsd_fetch_inferior_registers): Likewise.
(shnbsd_store_inferior_registers): Likewise.
* sol-thread.c (sol_thread_fetch_registers): Likewise.
(sol_thread_store_registers): Likewise.
* sparc-nat.c (fetch_inferior_registers): Likewise.
(store_inferior_registers): Likewise.
* spu-linux-nat.c (spu_fetch_inferior_registers): Likewise.
(spu_store_inferior_registers): Likewise.
* target.c (debug_print_register): Likewise.
(debug_to_fetch_registers, debug_to_store_registers): Likewise.
* vaxbsd-nat.c (vaxbsd_fetch_inferior_registers): Likewise.
(vaxbsd_store_inferior_registers): Likewise.
* win32-nat.c (do_win32_fetch_inferior_registers): Likewise.
(win32_fetch_inferior_registers): Likewise.
(win32_store_inferior_registers): Likewise.
2007-05-06 Ulrich Weigand <uweigand@de.ibm.com>
* gdbcore.h (struct regcache): Add forward declaration.

16
gdb/aix-thread.c
View file

@ -1270,22 +1270,22 @@ fetch_regs_kernel_thread (struct regcache *regcache, int regno,
thread/process specified by inferior_ptid. */
static void
aix_thread_fetch_registers (int regno)
aix_thread_fetch_registers (struct regcache *regcache, int regno)
{
struct thread_info *thread;
pthdb_tid_t tid;
if (!PD_TID (inferior_ptid))
base_target.to_fetch_registers (regno);
base_target.to_fetch_registers (regcache, regno);
else
{
thread = find_thread_pid (inferior_ptid);
tid = thread->private->tid;
if (tid == PTHDB_INVALID_TID)
fetch_regs_user_thread (current_regcache, thread->private->pdtid);
fetch_regs_user_thread (regcache, thread->private->pdtid);
else
fetch_regs_kernel_thread (current_regcache, regno, tid);
fetch_regs_kernel_thread (regcache, regno, tid);
}
}
@ -1602,22 +1602,22 @@ store_regs_kernel_thread (const struct regcache *regcache, int regno,
thread/process specified by inferior_ptid. */
static void
aix_thread_store_registers (int regno)
aix_thread_store_registers (struct regcache *regcache, int regno)
{
struct thread_info *thread;
pthdb_tid_t tid;
if (!PD_TID (inferior_ptid))
base_target.to_store_registers (regno);
base_target.to_store_registers (regcache, regno);
else
{
thread = find_thread_pid (inferior_ptid);
tid = thread->private->tid;
if (tid == PTHDB_INVALID_TID)
store_regs_user_thread (current_regcache, thread->private->pdtid);
store_regs_user_thread (regcache, thread->private->pdtid);
else
store_regs_kernel_thread (current_regcache, regno, tid);
store_regs_kernel_thread (regcache, regno, tid);
}
}

12
gdb/alphabsd-nat.c
View file

@ -86,7 +86,7 @@ getregs_supplies (int regno)
for all registers (including the floating point registers). */
static void
alphabsd_fetch_inferior_registers (int regno)
alphabsd_fetch_inferior_registers (struct regcache *regcache, int regno)
{
if (regno == -1 || getregs_supplies (regno))
{
@ -96,7 +96,7 @@ alphabsd_fetch_inferior_registers (int regno)
(PTRACE_TYPE_ARG3) &gregs, 0) == -1)
perror_with_name (_("Couldn't get registers"));
alphabsd_supply_reg (current_regcache, (char *) &gregs, regno);
alphabsd_supply_reg (regcache, (char *) &gregs, regno);
if (regno != -1)
return;
}
@ -109,7 +109,7 @@ alphabsd_fetch_inferior_registers (int regno)
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
perror_with_name (_("Couldn't get floating point status"));
alphabsd_supply_fpreg (current_regcache, (char *) &fpregs, regno);
alphabsd_supply_fpreg (regcache, (char *) &fpregs, regno);
}
}
@ -117,7 +117,7 @@ alphabsd_fetch_inferior_registers (int regno)
this for all registers (including the floating point registers). */
static void
alphabsd_store_inferior_registers (int regno)
alphabsd_store_inferior_registers (struct regcache *regcache, int regno)
{
if (regno == -1 || getregs_supplies (regno))
{
@ -126,7 +126,7 @@ alphabsd_store_inferior_registers (int regno)
(PTRACE_TYPE_ARG3) &gregs, 0) == -1)
perror_with_name (_("Couldn't get registers"));
alphabsd_fill_reg (current_regcache, (char *) &gregs, regno);
alphabsd_fill_reg (regcache, (char *) &gregs, regno);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &gregs, 0) == -1)
@ -144,7 +144,7 @@ alphabsd_store_inferior_registers (int regno)
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
perror_with_name (_("Couldn't get floating point status"));
alphabsd_fill_fpreg (current_regcache, (char *) &fpregs, regno);
alphabsd_fill_fpreg (regcache, (char *) &fpregs, regno);
if (ptrace (PT_SETFPREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)

12
gdb/amd64-linux-nat.c
View file

@ -157,7 +157,7 @@ fill_fpregset (const struct regcache *regcache,
registers). */
static void
amd64_linux_fetch_inferior_registers (int regnum)
amd64_linux_fetch_inferior_registers (struct regcache *regcache, int regnum)
{
int tid;
@ -173,7 +173,7 @@ amd64_linux_fetch_inferior_registers (int regnum)
if (ptrace (PTRACE_GETREGS, tid, 0, (long) &regs) < 0)
perror_with_name (_("Couldn't get registers"));
amd64_supply_native_gregset (current_regcache, &regs, -1);
amd64_supply_native_gregset (regcache, &regs, -1);
if (regnum != -1)
return;
}
@ -185,7 +185,7 @@ amd64_linux_fetch_inferior_registers (int regnum)
if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0)
perror_with_name (_("Couldn't get floating point status"));
amd64_supply_fxsave (current_regcache, -1, &fpregs);
amd64_supply_fxsave (regcache, -1, &fpregs);
}
}
@ -194,7 +194,7 @@ amd64_linux_fetch_inferior_registers (int regnum)
registers). */
static void
amd64_linux_store_inferior_registers (int regnum)
amd64_linux_store_inferior_registers (struct regcache *regcache, int regnum)
{
int tid;
@ -210,7 +210,7 @@ amd64_linux_store_inferior_registers (int regnum)
if (ptrace (PTRACE_GETREGS, tid, 0, (long) &regs) < 0)
perror_with_name (_("Couldn't get registers"));
amd64_collect_native_gregset (current_regcache, &regs, regnum);
amd64_collect_native_gregset (regcache, &regs, regnum);
if (ptrace (PTRACE_SETREGS, tid, 0, (long) &regs) < 0)
perror_with_name (_("Couldn't write registers"));
@ -226,7 +226,7 @@ amd64_linux_store_inferior_registers (int regnum)
if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0)
perror_with_name (_("Couldn't get floating point status"));
amd64_collect_fxsave (current_regcache, regnum, &fpregs);
amd64_collect_fxsave (regcache, regnum, &fpregs);
if (ptrace (PTRACE_SETFPREGS, tid, 0, (long) &fpregs) < 0)
perror_with_name (_("Couldn't write floating point status"));

12
gdb/amd64bsd-nat.c
View file

@ -41,7 +41,7 @@
for all registers (including the floating-point registers). */
static void
amd64bsd_fetch_inferior_registers (int regnum)
amd64bsd_fetch_inferior_registers (struct regcache *regcache, int regnum)
{
if (regnum == -1 || amd64_native_gregset_supplies_p (regnum))
{
@ -51,7 +51,7 @@ amd64bsd_fetch_inferior_registers (int regnum)
(PTRACE_TYPE_ARG3) &regs, 0) == -1)
perror_with_name (_("Couldn't get registers"));
amd64_supply_native_gregset (current_regcache, &regs, -1);
amd64_supply_native_gregset (regcache, &regs, -1);
if (regnum != -1)
return;
}
@ -64,7 +64,7 @@ amd64bsd_fetch_inferior_registers (int regnum)
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
perror_with_name (_("Couldn't get floating point status"));
amd64_supply_fxsave (current_regcache, -1, &fpregs);
amd64_supply_fxsave (regcache, -1, &fpregs);
}
}
@ -72,7 +72,7 @@ amd64bsd_fetch_inferior_registers (int regnum)
this for all registers (including the floating-point registers). */
static void
amd64bsd_store_inferior_registers (int regnum)
amd64bsd_store_inferior_registers (struct regcache *regcache, int regnum)
{
if (regnum == -1 || amd64_native_gregset_supplies_p (regnum))
{
@ -82,7 +82,7 @@ amd64bsd_store_inferior_registers (int regnum)
(PTRACE_TYPE_ARG3) &regs, 0) == -1)
perror_with_name (_("Couldn't get registers"));
amd64_collect_native_gregset (current_regcache, &regs, regnum);
amd64_collect_native_gregset (regcache, &regs, regnum);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &regs, 0) == -1)
@ -100,7 +100,7 @@ amd64bsd_store_inferior_registers (int regnum)
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
perror_with_name (_("Couldn't get floating point status"));
amd64_collect_fxsave (current_regcache, regnum, &fpregs);
amd64_collect_fxsave (regcache, regnum, &fpregs);
if (ptrace (PT_SETFPREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)

122
gdb/arm-linux-nat.c
View file

@ -93,7 +93,7 @@ get_thread_id (ptid_t ptid)
state of the process and store it into regcache. */
static void
fetch_fpregister (int regno)
fetch_fpregister (struct regcache *regcache, int regno)
{
int ret, tid;
gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
@ -111,19 +111,19 @@ fetch_fpregister (int regno)
/* Fetch fpsr. */
if (ARM_FPS_REGNUM == regno)
regcache_raw_supply (current_regcache, ARM_FPS_REGNUM,
regcache_raw_supply (regcache, ARM_FPS_REGNUM,
fp + NWFPE_FPSR_OFFSET);
/* Fetch the floating point register. */
if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM)
supply_nwfpe_register (current_regcache, regno, fp);
supply_nwfpe_register (regcache, regno, fp);
}
/* Get the whole floating point state of the process and store it
into regcache. */
static void
fetch_fpregs (void)
fetch_fpregs (struct regcache *regcache)
{
int ret, regno, tid;
gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
@ -140,19 +140,19 @@ fetch_fpregs (void)
}
/* Fetch fpsr. */
regcache_raw_supply (current_regcache, ARM_FPS_REGNUM,
regcache_raw_supply (regcache, ARM_FPS_REGNUM,
fp + NWFPE_FPSR_OFFSET);
/* Fetch the floating point registers. */
for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
supply_nwfpe_register (current_regcache, regno, fp);
supply_nwfpe_register (regcache, regno, fp);
}
/* Save a particular register into the floating point state of the
process using the contents from regcache. */
static void
store_fpregister (int regno)
store_fpregister (const struct regcache *regcache, int regno)
{
int ret, tid;
gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
@ -169,13 +169,12 @@ store_fpregister (int regno)
}
/* Store fpsr. */
if (ARM_FPS_REGNUM == regno && register_cached (ARM_FPS_REGNUM))
regcache_raw_collect (current_regcache, ARM_FPS_REGNUM,
fp + NWFPE_FPSR_OFFSET);
if (ARM_FPS_REGNUM == regno && regcache_valid_p (regcache, ARM_FPS_REGNUM))
regcache_raw_collect (regcache, ARM_FPS_REGNUM, fp + NWFPE_FPSR_OFFSET);
/* Store the floating point register. */
if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM)
collect_nwfpe_register (current_regcache, regno, fp);
collect_nwfpe_register (regcache, regno, fp);
ret = ptrace (PTRACE_SETFPREGS, tid, 0, fp);
if (ret < 0)
@ -189,7 +188,7 @@ store_fpregister (int regno)
the contents from regcache. */
static void
store_fpregs (void)
store_fpregs (const struct regcache *regcache)
{
int ret, regno, tid;
gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
@ -206,14 +205,13 @@ store_fpregs (void)
}
/* Store fpsr. */
if (register_cached (ARM_FPS_REGNUM))
regcache_raw_collect (current_regcache, ARM_FPS_REGNUM,
fp + NWFPE_FPSR_OFFSET);
if (regcache_valid_p (regcache, ARM_FPS_REGNUM))
regcache_raw_collect (regcache, ARM_FPS_REGNUM, fp + NWFPE_FPSR_OFFSET);
/* Store the floating point registers. */
for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
if (register_cached (regno))
collect_nwfpe_register (current_regcache, regno, fp);
if (regcache_valid_p (regcache, regno))
collect_nwfpe_register (regcache, regno, fp);
ret = ptrace (PTRACE_SETFPREGS, tid, 0, fp);
if (ret < 0)
@ -227,7 +225,7 @@ store_fpregs (void)
regcache. */
static void
fetch_register (int regno)
fetch_register (struct regcache *regcache, int regno)
{
int ret, tid;
elf_gregset_t regs;
@ -243,22 +241,22 @@ fetch_register (int regno)
}
if (regno >= ARM_A1_REGNUM && regno < ARM_PC_REGNUM)
regcache_raw_supply (current_regcache, regno, (char *) &regs[regno]);
regcache_raw_supply (regcache, regno, (char *) &regs[regno]);
if (ARM_PS_REGNUM == regno)
{
if (arm_apcs_32)
regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
regcache_raw_supply (regcache, ARM_PS_REGNUM,
(char *) &regs[ARM_CPSR_REGNUM]);
else
regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
regcache_raw_supply (regcache, ARM_PS_REGNUM,
(char *) &regs[ARM_PC_REGNUM]);
}
if (ARM_PC_REGNUM == regno)
{
regs[ARM_PC_REGNUM] = ADDR_BITS_REMOVE (regs[ARM_PC_REGNUM]);
regcache_raw_supply (current_regcache, ARM_PC_REGNUM,
regcache_raw_supply (regcache, ARM_PC_REGNUM,
(char *) &regs[ARM_PC_REGNUM]);
}
}
@ -267,7 +265,7 @@ fetch_register (int regno)
regcache. */
static void
fetch_regs (void)
fetch_regs (struct regcache *regcache)
{
int ret, regno, tid;
elf_gregset_t regs;
@ -283,17 +281,17 @@ fetch_regs (void)
}
for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
regcache_raw_supply (current_regcache, regno, (char *) &regs[regno]);
regcache_raw_supply (regcache, regno, (char *) &regs[regno]);
if (arm_apcs_32)
regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
regcache_raw_supply (regcache, ARM_PS_REGNUM,
(char *) &regs[ARM_CPSR_REGNUM]);
else
regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
regcache_raw_supply (regcache, ARM_PS_REGNUM,
(char *) &regs[ARM_PC_REGNUM]);
regs[ARM_PC_REGNUM] = ADDR_BITS_REMOVE (regs[ARM_PC_REGNUM]);
regcache_raw_supply (current_regcache, ARM_PC_REGNUM,
regcache_raw_supply (regcache, ARM_PC_REGNUM,
(char *) &regs[ARM_PC_REGNUM]);
}
@ -301,12 +299,12 @@ fetch_regs (void)
regcache. */
static void
store_register (int regno)
store_register (const struct regcache *regcache, int regno)
{
int ret, tid;
elf_gregset_t regs;
if (!register_cached (regno))
if (!regcache_valid_p (regcache, regno))
return;
/* Get the thread id for the ptrace call. */
@ -321,12 +319,12 @@ store_register (int regno)
}
if (regno >= ARM_A1_REGNUM && regno <= ARM_PC_REGNUM)
regcache_raw_collect (current_regcache, regno, (char *) &regs[regno]);
regcache_raw_collect (regcache, regno, (char *) &regs[regno]);
else if (arm_apcs_32 && regno == ARM_PS_REGNUM)
regcache_raw_collect (current_regcache, regno,
regcache_raw_collect (regcache, regno,
(char *) &regs[ARM_CPSR_REGNUM]);
else if (!arm_apcs_32 && regno == ARM_PS_REGNUM)
regcache_raw_collect (current_regcache, ARM_PC_REGNUM,
regcache_raw_collect (regcache, ARM_PC_REGNUM,
(char *) &regs[ARM_PC_REGNUM]);
ret = ptrace (PTRACE_SETREGS, tid, 0, &regs);
@ -338,7 +336,7 @@ store_register (int regno)
}
static void
store_regs (void)
store_regs (const struct regcache *regcache)
{
int ret, regno, tid;
elf_gregset_t regs;
@ -356,12 +354,12 @@ store_regs (void)
for (regno = ARM_A1_REGNUM; regno <= ARM_PC_REGNUM; regno++)
{
if (register_cached (regno))
regcache_raw_collect (current_regcache, regno, (char *) &regs[regno]);
if (regcache_valid_p (regcache, regno))
regcache_raw_collect (regcache, regno, (char *) &regs[regno]);
}
if (arm_apcs_32 && register_cached (ARM_PS_REGNUM))
regcache_raw_collect (current_regcache, ARM_PS_REGNUM,
if (arm_apcs_32 && regcache_valid_p (regcache, ARM_PS_REGNUM))
regcache_raw_collect (regcache, ARM_PS_REGNUM,
(char *) &regs[ARM_CPSR_REGNUM]);
ret = ptrace (PTRACE_SETREGS, tid, 0, &regs);
@ -379,7 +377,7 @@ store_regs (void)
#define IWMMXT_REGS_SIZE (16 * 8 + 6 * 4)
static void
fetch_wmmx_regs (void)
fetch_wmmx_regs (struct regcache *regcache)
{
char regbuf[IWMMXT_REGS_SIZE];
int ret, regno, tid;
@ -395,20 +393,20 @@ fetch_wmmx_regs (void)
}
for (regno = 0; regno < 16; regno++)
regcache_raw_supply (current_regcache, regno + ARM_WR0_REGNUM,
regcache_raw_supply (regcache, regno + ARM_WR0_REGNUM,
&regbuf[regno * 8]);
for (regno = 0; regno < 2; regno++)
regcache_raw_supply (current_regcache, regno + ARM_WCSSF_REGNUM,
regcache_raw_supply (regcache, regno + ARM_WCSSF_REGNUM,
&regbuf[16 * 8 + regno * 4]);
for (regno = 0; regno < 4; regno++)
regcache_raw_supply (current_regcache, regno + ARM_WCGR0_REGNUM,
regcache_raw_supply (regcache, regno + ARM_WCGR0_REGNUM,
&regbuf[16 * 8 + 2 * 4 + regno * 4]);
}
static void
store_wmmx_regs (void)
store_wmmx_regs (const struct regcache *regcache)
{
char regbuf[IWMMXT_REGS_SIZE];
int ret, regno, tid;
@ -424,18 +422,18 @@ store_wmmx_regs (void)
}
for (regno = 0; regno < 16; regno++)
if (register_cached (regno + ARM_WR0_REGNUM))
regcache_raw_collect (current_regcache, regno + ARM_WR0_REGNUM,
if (regcache_valid_p (regcache, regno + ARM_WR0_REGNUM))
regcache_raw_collect (regcache, regno + ARM_WR0_REGNUM,
&regbuf[regno * 8]);
for (regno = 0; regno < 2; regno++)
if (register_cached (regno + ARM_WCSSF_REGNUM))
regcache_raw_collect (current_regcache, regno + ARM_WCSSF_REGNUM,
if (regcache_valid_p (regcache, regno + ARM_WCSSF_REGNUM))
regcache_raw_collect (regcache, regno + ARM_WCSSF_REGNUM,
&regbuf[16 * 8 + regno * 4]);
for (regno = 0; regno < 4; regno++)
if (register_cached (regno + ARM_WCGR0_REGNUM))
regcache_raw_collect (current_regcache, regno + ARM_WCGR0_REGNUM,
if (regcache_valid_p (regcache, regno + ARM_WCGR0_REGNUM))
regcache_raw_collect (regcache, regno + ARM_WCGR0_REGNUM,
&regbuf[16 * 8 + 2 * 4 + regno * 4]);
ret = ptrace (PTRACE_SETWMMXREGS, tid, 0, regbuf);
@ -452,24 +450,24 @@ store_wmmx_regs (void)
point registers depending upon the value of regno. */
static void
arm_linux_fetch_inferior_registers (int regno)
arm_linux_fetch_inferior_registers (struct regcache *regcache, int regno)
{
if (-1 == regno)
{
fetch_regs ();
fetch_fpregs ();
fetch_regs (regcache);
fetch_fpregs (regcache);
if (arm_linux_has_wmmx_registers)
fetch_wmmx_regs ();
fetch_wmmx_regs (regcache);
}
else
{
if (regno < ARM_F0_REGNUM || regno == ARM_PS_REGNUM)
fetch_register (regno);
fetch_register (regcache, regno);
else if (regno >= ARM_F0_REGNUM && regno <= ARM_FPS_REGNUM)
fetch_fpregister (regno);
fetch_fpregister (regcache, regno);
else if (arm_linux_has_wmmx_registers
&& regno >= ARM_WR0_REGNUM && regno <= ARM_WCGR7_REGNUM)
fetch_wmmx_regs ();
fetch_wmmx_regs (regcache);
}
}
@ -478,24 +476,24 @@ arm_linux_fetch_inferior_registers (int regno)
point registers depending upon the value of regno. */
static void
arm_linux_store_inferior_registers (int regno)
arm_linux_store_inferior_registers (struct regcache *regcache, int regno)
{
if (-1 == regno)
{
store_regs ();
store_fpregs ();
store_regs (regcache);
store_fpregs (regcache);
if (arm_linux_has_wmmx_registers)
store_wmmx_regs ();
store_wmmx_regs (regcache);
}
else
{
if (regno < ARM_F0_REGNUM || regno == ARM_PS_REGNUM)
store_register (regno);
store_register (regcache, regno);
else if ((regno >= ARM_F0_REGNUM) && (regno <= ARM_FPS_REGNUM))
store_fpregister (regno);
store_fpregister (regcache, regno);
else if (arm_linux_has_wmmx_registers
&& regno >= ARM_WR0_REGNUM && regno <= ARM_WCGR7_REGNUM)
store_wmmx_regs ();
store_wmmx_regs (regcache);
}
}

92
gdb/armnbsd-nat.c
View file

@ -77,7 +77,7 @@ arm_supply_fparegset (struct regcache *regcache, struct fpreg *fparegset)
}
static void
fetch_register (int regno)
fetch_register (struct regcache *regcache, int regno)
{
struct reg inferior_registers;
int ret;
@ -94,40 +94,40 @@ fetch_register (int regno)
switch (regno)
{
case ARM_SP_REGNUM:
regcache_raw_supply (current_regcache, ARM_SP_REGNUM,
regcache_raw_supply (regcache, ARM_SP_REGNUM,
(char *) &inferior_registers.r_sp);
break;
case ARM_LR_REGNUM:
regcache_raw_supply (current_regcache, ARM_LR_REGNUM,
regcache_raw_supply (regcache, ARM_LR_REGNUM,
(char *) &inferior_registers.r_lr);
break;
case ARM_PC_REGNUM:
/* This is ok: we're running native... */
inferior_registers.r_pc = ADDR_BITS_REMOVE (inferior_registers.r_pc);
regcache_raw_supply (current_regcache, ARM_PC_REGNUM,
regcache_raw_supply (regcache, ARM_PC_REGNUM,
(char *) &inferior_registers.r_pc);
break;
case ARM_PS_REGNUM:
if (arm_apcs_32)
regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
regcache_raw_supply (regcache, ARM_PS_REGNUM,
(char *) &inferior_registers.r_cpsr);
else
regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
regcache_raw_supply (regcache, ARM_PS_REGNUM,
(char *) &inferior_registers.r_pc);
break;
default:
regcache_raw_supply (current_regcache, regno,
regcache_raw_supply (regcache, regno,
(char *) &inferior_registers.r[regno]);
break;
}
}
static void
fetch_regs (void)
fetch_regs (struct regcache *regcache)
{
struct reg inferior_registers;
int ret;
@ -142,11 +142,11 @@ fetch_regs (void)
return;
}
arm_supply_gregset (current_regcache, &inferior_registers);
arm_supply_gregset (regcache, &inferior_registers);
}
static void
fetch_fp_register (int regno)
fetch_fp_register (struct regcache *regcache, int regno)
{
struct fpreg inferior_fp_registers;
int ret;
@ -163,19 +163,19 @@ fetch_fp_register (int regno)
switch (regno)
{
case ARM_FPS_REGNUM:
regcache_raw_supply (current_regcache, ARM_FPS_REGNUM,
regcache_raw_supply (regcache, ARM_FPS_REGNUM,
(char *) &inferior_fp_registers.fpr_fpsr);
break;
default:
regcache_raw_supply (current_regcache, regno,
regcache_raw_supply (regcache, regno,
(char *) &inferior_fp_registers.fpr[regno - ARM_F0_REGNUM]);
break;
}
}
static void
fetch_fp_regs (void)
fetch_fp_regs (struct regcache *regcache)
{
struct fpreg inferior_fp_registers;
int ret;
@ -190,29 +190,29 @@ fetch_fp_regs (void)
return;
}
arm_supply_fparegset (current_regcache, &inferior_fp_registers);
arm_supply_fparegset (regcache, &inferior_fp_registers);
}
static void
armnbsd_fetch_registers (int regno)
armnbsd_fetch_registers (struct regcache *regcache, int regno)
{
if (regno >= 0)
{
if (regno < ARM_F0_REGNUM || regno > ARM_FPS_REGNUM)
fetch_register (regno);
fetch_register (regcache, regno);
else
fetch_fp_register (regno);
fetch_fp_register (regcache, regno);
}
else
{
fetch_regs ();
fetch_fp_regs ();
fetch_regs (regcache);
fetch_fp_regs (regcache);
}
}
static void
store_register (int regno)
store_register (const struct regcache *regcache, int regno)
{
struct reg inferior_registers;
int ret;
@ -229,24 +229,24 @@ store_register (int regno)
switch (regno)
{
case ARM_SP_REGNUM:
regcache_raw_collect (current_regcache, ARM_SP_REGNUM,
regcache_raw_collect (regcache, ARM_SP_REGNUM,
(char *) &inferior_registers.r_sp);
break;
case ARM_LR_REGNUM:
regcache_raw_collect (current_regcache, ARM_LR_REGNUM,
regcache_raw_collect (regcache, ARM_LR_REGNUM,
(char *) &inferior_registers.r_lr);
break;
case ARM_PC_REGNUM:
if (arm_apcs_32)
regcache_raw_collect (current_regcache, ARM_PC_REGNUM,
regcache_raw_collect (regcache, ARM_PC_REGNUM,
(char *) &inferior_registers.r_pc);
else
{
unsigned pc_val;
regcache_raw_collect (current_regcache, ARM_PC_REGNUM,
regcache_raw_collect (regcache, ARM_PC_REGNUM,
(char *) &pc_val);
pc_val = ADDR_BITS_REMOVE (pc_val);
@ -258,13 +258,13 @@ store_register (int regno)
case ARM_PS_REGNUM:
if (arm_apcs_32)
regcache_raw_collect (current_regcache, ARM_PS_REGNUM,
regcache_raw_collect (regcache, ARM_PS_REGNUM,
(char *) &inferior_registers.r_cpsr);
else
{
unsigned psr_val;
regcache_raw_collect (current_regcache, ARM_PS_REGNUM,
regcache_raw_collect (regcache, ARM_PS_REGNUM,
(char *) &psr_val);
psr_val ^= ADDR_BITS_REMOVE (psr_val);
@ -274,7 +274,7 @@ store_register (int regno)
break;
default:
regcache_raw_collect (current_regcache, regno,
regcache_raw_collect (regcache, regno,
(char *) &inferior_registers.r[regno]);
break;
}
@ -287,7 +287,7 @@ store_register (int regno)
}
static void
store_regs (void)
store_regs (const struct regcache *regcache)
{
struct reg inferior_registers;
int ret;
@ -295,19 +295,19 @@ store_regs (void)
for (regno = ARM_A1_REGNUM; regno < ARM_SP_REGNUM; regno++)
regcache_raw_collect (current_regcache, regno,
regcache_raw_collect (regcache, regno,
(char *) &inferior_registers.r[regno]);
regcache_raw_collect (current_regcache, ARM_SP_REGNUM,
regcache_raw_collect (regcache, ARM_SP_REGNUM,
(char *) &inferior_registers.r_sp);
regcache_raw_collect (current_regcache, ARM_LR_REGNUM,
regcache_raw_collect (regcache, ARM_LR_REGNUM,
(char *) &inferior_registers.r_lr);
if (arm_apcs_32)
{
regcache_raw_collect (current_regcache, ARM_PC_REGNUM,
regcache_raw_collect (regcache, ARM_PC_REGNUM,
(char *) &inferior_registers.r_pc);
regcache_raw_collect (current_regcache, ARM_PS_REGNUM,
regcache_raw_collect (regcache, ARM_PS_REGNUM,
(char *) &inferior_registers.r_cpsr);
}
else
@ -315,9 +315,9 @@ store_regs (void)
unsigned pc_val;
unsigned psr_val;
regcache_raw_collect (current_regcache, ARM_PC_REGNUM,
regcache_raw_collect (regcache, ARM_PC_REGNUM,
(char *) &pc_val);
regcache_raw_collect (current_regcache, ARM_PS_REGNUM,
regcache_raw_collect (regcache, ARM_PS_REGNUM,
(char *) &psr_val);
pc_val = ADDR_BITS_REMOVE (pc_val);
@ -334,7 +334,7 @@ store_regs (void)
}
static void
store_fp_register (int regno)
store_fp_register (const struct regcache *regcache, int regno)
{
struct fpreg inferior_fp_registers;
int ret;
@ -351,12 +351,12 @@ store_fp_register (int regno)
switch (regno)
{
case ARM_FPS_REGNUM:
regcache_raw_collect (current_regcache, ARM_FPS_REGNUM,
regcache_raw_collect (regcache, ARM_FPS_REGNUM,
(char *) &inferior_fp_registers.fpr_fpsr);
break;
default:
regcache_raw_collect (current_regcache, regno,
regcache_raw_collect (regcache, regno,
(char *) &inferior_fp_registers.fpr[regno - ARM_F0_REGNUM]);
break;
}
@ -369,7 +369,7 @@ store_fp_register (int regno)
}
static void
store_fp_regs (void)
store_fp_regs (const struct regcache *regcache)
{
struct fpreg inferior_fp_registers;
int ret;
@ -377,10 +377,10 @@ store_fp_regs (void)
for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
regcache_raw_collect (current_regcache, regno,
regcache_raw_collect (regcache, regno,
(char *) &inferior_fp_registers.fpr[regno - ARM_F0_REGNUM]);
regcache_raw_collect (current_regcache, ARM_FPS_REGNUM,
regcache_raw_collect (regcache, ARM_FPS_REGNUM,
(char *) &inferior_fp_registers.fpr_fpsr);
ret = ptrace (PT_SETFPREGS, PIDGET (inferior_ptid),
@ -391,19 +391,19 @@ store_fp_regs (void)
}
static void
armnbsd_store_registers (int regno)
armnbsd_store_registers (struct regcache *regcache, int regno)
{
if (regno >= 0)
{
if (regno < ARM_F0_REGNUM || regno > ARM_FPS_REGNUM)
store_register (regno);
store_register (regcache, regno);
else
store_fp_register (regno);
store_fp_register (regcache, regno);
}
else
{
store_regs ();
store_fp_regs ();
store_regs (regcache);
store_fp_regs (regcache);
}
}

20
gdb/bsd-kvm.c
View file

@ -91,7 +91,7 @@ bsd_kvm_open (char *filename, int from_tty)
core_kd = temp_kd;
push_target (&bsd_kvm_ops);
target_fetch_registers (-1);
target_fetch_registers (current_regcache, -1);
reinit_frame_cache ();
print_stack_frame (get_selected_frame (NULL), -1, 1);
@ -150,7 +150,7 @@ bsd_kvm_files_info (struct target_ops *ops)
/* Fetch process control block at address PADDR. */
static int
bsd_kvm_fetch_pcb (struct pcb *paddr)
bsd_kvm_fetch_pcb (struct regcache *regcache, struct pcb *paddr)
{
struct pcb pcb;
@ -158,17 +158,17 @@ bsd_kvm_fetch_pcb (struct pcb *paddr)
error (("%s"), kvm_geterr (core_kd));
gdb_assert (bsd_kvm_supply_pcb);
return bsd_kvm_supply_pcb (current_regcache, &pcb);
return bsd_kvm_supply_pcb (regcache, &pcb);
}
static void
bsd_kvm_fetch_registers (int regnum)
bsd_kvm_fetch_registers (struct regcache *regcache, int regnum)
{
struct nlist nl[2];
if (bsd_kvm_paddr)
{
bsd_kvm_fetch_pcb (bsd_kvm_paddr);
bsd_kvm_fetch_pcb (regcache, bsd_kvm_paddr);
return;
}
@ -184,7 +184,7 @@ bsd_kvm_fetch_registers (int regnum)
{
/* Found dumppcb. If it contains a valid context, return
immediately. */
if (bsd_kvm_fetch_pcb ((struct pcb *) nl[0].n_value))
if (bsd_kvm_fetch_pcb (regcache, (struct pcb *) nl[0].n_value))
return;
}
@ -206,7 +206,7 @@ bsd_kvm_fetch_registers (int regnum)
if (kvm_read (core_kd, nl[0].n_value, &paddr, sizeof paddr) == -1)
error (("%s"), kvm_geterr (core_kd));
bsd_kvm_fetch_pcb (paddr);
bsd_kvm_fetch_pcb (regcache, paddr);
return;
}
@ -231,7 +231,7 @@ bsd_kvm_fetch_registers (int regnum)
if (kvm_read (core_kd, nl[0].n_value, &paddr, sizeof paddr) == -1)
error (("%s"), kvm_geterr (core_kd));
bsd_kvm_fetch_pcb (paddr);
bsd_kvm_fetch_pcb (regcache, paddr);
return;
}
#endif
@ -273,7 +273,7 @@ bsd_kvm_proc_cmd (char *arg, int fromtty)
if (kvm_read (core_kd, addr, &bsd_kvm_paddr, sizeof bsd_kvm_paddr) == -1)
error (("%s"), kvm_geterr (core_kd));
target_fetch_registers (-1);
target_fetch_registers (current_regcache, -1);
reinit_frame_cache ();
print_stack_frame (get_selected_frame (NULL), -1, 1);
@ -293,7 +293,7 @@ bsd_kvm_pcb_cmd (char *arg, int fromtty)
bsd_kvm_paddr = (struct pcb *)(u_long) parse_and_eval_address (arg);
target_fetch_registers (-1);
target_fetch_registers (current_regcache, -1);
reinit_frame_cache ();
print_stack_frame (get_selected_frame (NULL), -1, 1);

12
gdb/bsd-uthread.c
View file

@ -266,7 +266,7 @@ bsd_uthread_mourn_inferior (void)
}
static void
bsd_uthread_fetch_registers (int regnum)
bsd_uthread_fetch_registers (struct regcache *regcache, int regnum)
{
struct gdbarch *gdbarch = current_gdbarch;
struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
@ -274,7 +274,7 @@ bsd_uthread_fetch_registers (int regnum)
CORE_ADDR active_addr;
/* Always fetch the appropriate registers from the layer beneath. */
find_target_beneath (bsd_uthread_ops_hack)->to_fetch_registers (regnum);
find_target_beneath (bsd_uthread_ops_hack)->to_fetch_registers (regcache, regnum);
/* FIXME: That might have gotten us more than we asked for. Make
sure we overwrite all relevant registers with values from the
@ -286,13 +286,13 @@ bsd_uthread_fetch_registers (int regnum)
if (addr != 0 && addr != active_addr)
{
bsd_uthread_check_magic (addr);
ops->supply_uthread (current_regcache, regnum,
ops->supply_uthread (regcache, regnum,
addr + bsd_uthread_thread_ctx_offset);
}
}
static void
bsd_uthread_store_registers (int regnum)
bsd_uthread_store_registers (struct regcache *regcache, int regnum)
{
struct gdbarch *gdbarch = current_gdbarch;
struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
@ -304,14 +304,14 @@ bsd_uthread_store_registers (int regnum)
if (addr != 0 && addr != active_addr)
{
bsd_uthread_check_magic (addr);
ops->collect_uthread (current_regcache, regnum,
ops->collect_uthread (regcache, regnum,
addr + bsd_uthread_thread_ctx_offset);
}
else
{
/* Updating the thread that is currently running; pass the
request to the layer beneath. */
find_target_beneath (bsd_uthread_ops_hack)->to_store_registers (regnum);
find_target_beneath (bsd_uthread_ops_hack)->to_store_registers (regcache, regnum);
}
}

12
gdb/corelow.c
View file

@ -82,7 +82,7 @@ static void core_close (int);
static void core_close_cleanup (void *ignore);
static void get_core_registers (int);
static void get_core_registers (struct regcache *, int);
static void add_to_thread_list (bfd *, asection *, void *);
@ -375,7 +375,7 @@ core_open (char *filename, int from_tty)
if (ontop)
{
/* Fetch all registers from core file. */
target_fetch_registers (-1);
target_fetch_registers (current_regcache, -1);
/* Now, set up the frame cache, and print the top of stack. */
reinit_frame_cache ();
@ -483,7 +483,7 @@ get_core_register_section (struct regcache *regcache,
/* We just get all the registers, so we don't use regno. */
static void
get_core_registers (int regno)
get_core_registers (struct regcache *regcache, int regno)
{
int status;
@ -495,11 +495,11 @@ get_core_registers (int regno)
return;
}
get_core_register_section (current_regcache,
get_core_register_section (regcache,
".reg", 0, "general-purpose", 1);
get_core_register_section (current_regcache,
get_core_register_section (regcache,
".reg2", 2, "floating-point", 0);
get_core_register_section (current_regcache,
get_core_register_section (regcache,
".reg-xfp", 3, "extended floating-point", 0);
deprecated_registers_fetched ();

4
gdb/gnu-nat.c
View file

@ -2584,8 +2584,8 @@ gnu_pid_to_str (ptid_t ptid)
}
extern void gnu_store_registers (int regno);
extern void gnu_fetch_registers (int regno);
extern void gnu_store_registers (struct regcache *regcache, int regno);
extern void gnu_fetch_registers (struct regcache *regcache, int regno);
struct target_ops gnu_ops;

34
gdb/go32-nat.c
View file

@ -174,9 +174,9 @@ static void go32_resume (ptid_t ptid, int step,
enum target_signal siggnal);
static ptid_t go32_wait (ptid_t ptid,
struct target_waitstatus *status);
static void go32_fetch_registers (int regno);
static void store_register (int regno);
static void go32_store_registers (int regno);
static void go32_fetch_registers (struct regcache *, int regno);
static void store_register (const struct regcache *, int regno);
static void go32_store_registers (struct regcache *, int regno);
static void go32_prepare_to_store (void);
static int go32_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
int write,
@ -465,56 +465,56 @@ go32_wait (ptid_t ptid, struct target_waitstatus *status)
}
static void
fetch_register (int regno)
fetch_register (struct regcache *regcache, int regno)
{
if (regno < FP0_REGNUM)
regcache_raw_supply (current_regcache, regno,
regcache_raw_supply (regcache, regno,
(char *) &a_tss + regno_mapping[regno].tss_ofs);
else if (i386_fp_regnum_p (regno) || i386_fpc_regnum_p (regno))
i387_supply_fsave (current_regcache, regno, &npx);
i387_supply_fsave (regcache, regno, &npx);
else
internal_error (__FILE__, __LINE__,
_("Invalid register no. %d in fetch_register."), regno);
}
static void
go32_fetch_registers (int regno)
go32_fetch_registers (struct regcache *regcache, int regno)
{
if (regno >= 0)
fetch_register (regno);
fetch_register (regcache, regno);
else
{
for (regno = 0; regno < FP0_REGNUM; regno++)
fetch_register (regno);
i387_supply_fsave (current_regcache, -1, &npx);
fetch_register (regcache, regno);
i387_supply_fsave (regcache, -1, &npx);
}
}
static void
store_register (int regno)
store_register (const struct regcache *regcache, int regno)
{
if (regno < FP0_REGNUM)
regcache_raw_collect (current_regcache, regno,
regcache_raw_collect (regcache, regno,
(char *) &a_tss + regno_mapping[regno].tss_ofs);
else if (i386_fp_regnum_p (regno) || i386_fpc_regnum_p (regno))
i387_collect_fsave (current_regcache, regno, &npx);
i387_collect_fsave (regcache, regno, &npx);
else
internal_error (__FILE__, __LINE__,
_("Invalid register no. %d in store_register."), regno);
}
static void
go32_store_registers (int regno)
go32_store_registers (struct regcache *regcache, int regno)
{
unsigned r;
if (regno >= 0)
store_register (regno);
store_register (regcache, regno);
else
{
for (r = 0; r < FP0_REGNUM; r++)
store_register (r);
i387_collect_fsave (current_regcache, -1, &npx);
store_register (regcache, r);
i387_collect_fsave (regcache, -1, &npx);
}
}

24
gdb/hppa-hpux-nat.c
View file

@ -87,7 +87,7 @@ hppa_hpux_save_state_offset (struct regcache *regcache, int regnum)
#endif
static void
hppa_hpux_fetch_register (int regnum)
hppa_hpux_fetch_register (struct regcache *regcache, int regnum)
{
CORE_ADDR addr;
size_t size;
@ -98,7 +98,7 @@ hppa_hpux_fetch_register (int regnum)
pid = ptid_get_pid (inferior_ptid);
/* This isn't really an address, but ptrace thinks of it as one. */
addr = hppa_hpux_save_state_offset(current_regcache, regnum);
addr = hppa_hpux_save_state_offset (regcache, regnum);
size = register_size (current_gdbarch, regnum);
gdb_assert (size == 4 || size == 8);
@ -138,23 +138,23 @@ hppa_hpux_fetch_register (int regnum)
store_unsigned_integer ((gdb_byte *)buf, 8, flags);
}
regcache_raw_supply (current_regcache, regnum, buf);
regcache_raw_supply (regcache, regnum, buf);
}
static void
hppa_hpux_fetch_inferior_registers (int regnum)
hppa_hpux_fetch_inferior_registers (struct regcache *regcache, int regnum)
{
if (regnum == -1)
for (regnum = 0; regnum < NUM_REGS; regnum++)
hppa_hpux_fetch_register (regnum);
hppa_hpux_fetch_register (regcache, regnum);
else
hppa_hpux_fetch_register (regnum);
hppa_hpux_fetch_register (regcache, regnum);
}
/* Store register REGNUM into the inferior. */
static void
hppa_hpux_store_register (int regnum)
hppa_hpux_store_register (struct regcache *regcache, int regnum)
{
CORE_ADDR addr;
size_t size;
@ -164,13 +164,13 @@ hppa_hpux_store_register (int regnum)
pid = ptid_get_pid (inferior_ptid);
/* This isn't really an address, but ptrace thinks of it as one. */
addr = hppa_hpux_save_state_offset(current_regcache, regnum);
addr = hppa_hpux_save_state_offset (regcache, regnum);
size = register_size (current_gdbarch, regnum);
gdb_assert (size == 4 || size == 8);
buf = alloca (size);
regcache_raw_collect (current_regcache, regnum, buf);
regcache_raw_collect (regcache, regnum, buf);
/* Take care with the "flags" register. It's stored as an `int' in
`struct save_state', even for 64-bit code. */
@ -212,13 +212,13 @@ hppa_hpux_store_register (int regnum)
this for all registers (including the floating point registers). */
static void
hppa_hpux_store_inferior_registers (int regnum)
hppa_hpux_store_inferior_registers (struct regcache *regcache, int regnum)
{
if (regnum == -1)
for (regnum = 0; regnum < NUM_REGS; regnum++)
hppa_hpux_store_register (regnum);
hppa_hpux_store_register (regcache, regnum);
else
hppa_hpux_store_register (regnum);
hppa_hpux_store_register (regcache, regnum);
}
static int

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

@ -216,14 +216,14 @@ static const int greg_map[] =
/* Fetch one register. */
static void
fetch_register (int regno)
fetch_register (struct regcache *regcache, int regno)
{
int tid;
int val;
if (CANNOT_FETCH_REGISTER (regno))
{
regcache_raw_supply (current_regcache, regno, NULL);
regcache_raw_supply (regcache, regno, NULL);
return;
}
@ -238,13 +238,13 @@ fetch_register (int regno)
error (_("Couldn't read register %s (#%d): %s."), REGISTER_NAME (regno),
regno, safe_strerror (errno));
regcache_raw_supply (current_regcache, regno, &val);
regcache_raw_supply (regcache, regno, &val);
}
/* Store one register. */
static void
store_register (int regno)
store_register (const struct regcache *regcache, int regno)
{
int tid;
int val;
@ -258,7 +258,7 @@ store_register (int regno)
tid = PIDGET (inferior_ptid); /* Not a threaded program. */
errno = 0;
regcache_raw_collect (current_regcache, regno, &val);
regcache_raw_collect (regcache, regno, &val);
ptrace (PTRACE_POKEUSER, tid, hppa_linux_register_addr (regno, 0), val);
if (errno != 0)
error (_("Couldn't write register %s (#%d): %s."), REGISTER_NAME (regno),
@ -270,16 +270,16 @@ store_register (int regno)
point registers depending upon the value of regno. */
static void
hppa_linux_fetch_inferior_registers (int regno)
hppa_linux_fetch_inferior_registers (struct regcache *regcache, int regno)
{
if (-1 == regno)
{
for (regno = 0; regno < NUM_REGS; regno++)
fetch_register (regno);
fetch_register (regcache, regno);
}
else
{
fetch_register (regno);
fetch_register (regcache, regno);
}
}
@ -288,16 +288,16 @@ hppa_linux_fetch_inferior_registers (int regno)
point registers depending upon the value of regno. */
static void
hppa_linux_store_inferior_registers (int regno)
hppa_linux_store_inferior_registers (struct regcache *regcache, int regno)
{
if (-1 == regno)
{
for (regno = 0; regno < NUM_REGS; regno++)
store_register (regno);
store_register (regcache, regno);
}
else
{
store_register (regno);
store_register (regcache, regno);
}
}

12
gdb/hppabsd-nat.c
View file

@ -124,10 +124,8 @@ hppabsd_collect_fpregset (struct regcache *regcache,
for all registers (including the floating-point registers). */
static void
hppabsd_fetch_registers (int regnum)
hppabsd_fetch_registers (struct regcache *regcache, int regnum)
{
struct regcache *regcache = current_regcache;
if (regnum == -1 || hppabsd_gregset_supplies_p (regnum))
{
struct reg regs;
@ -147,7 +145,7 @@ hppabsd_fetch_registers (int regnum)
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
perror_with_name (_("Couldn't get floating point status"));
hppabsd_supply_fpregset (current_regcache, &fpregs);
hppabsd_supply_fpregset (regcache, &fpregs);
}
}
@ -155,7 +153,7 @@ hppabsd_fetch_registers (int regnum)
this for all registers (including the floating-point registers). */
static void
hppabsd_store_registers (int regnum)
hppabsd_store_registers (struct regcache *regcache, int regnum)
{
if (regnum == -1 || hppabsd_gregset_supplies_p (regnum))
{
@ -165,7 +163,7 @@ hppabsd_store_registers (int regnum)
(PTRACE_TYPE_ARG3) &regs, 0) == -1)
perror_with_name (_("Couldn't get registers"));
hppabsd_collect_gregset (current_regcache, &regs, regnum);
hppabsd_collect_gregset (regcache, &regs, regnum);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &regs, 0) == -1)
@ -180,7 +178,7 @@ hppabsd_store_registers (int regnum)
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
perror_with_name (_("Couldn't get floating point status"));
hppabsd_collect_fpregset (current_regcache, &fpregs, regnum);
hppabsd_collect_fpregset (regcache, &fpregs, regnum);
if (ptrace (PT_SETFPREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)

22
gdb/hpux-thread.c
View file

@ -249,7 +249,7 @@ static char regmap[] =
};
static void
hpux_thread_fetch_registers (int regno)
hpux_thread_fetch_registers (struct regcache *regcache, int regno)
{
cma__t_int_tcb tcb, *tcb_ptr;
struct cleanup *old_chain;
@ -264,7 +264,7 @@ hpux_thread_fetch_registers (int regno)
if (tcb_ptr->state == cma__c_state_running)
{
deprecated_child_ops.to_fetch_registers (regno);
deprecated_child_ops.to_fetch_registers (regcache, regno);
do_cleanups (old_chain);
@ -285,7 +285,7 @@ hpux_thread_fetch_registers (int regno)
for (regno = first_regno; regno <= last_regno; regno++)
{
if (regmap[regno] == -1)
deprecated_child_ops.to_fetch_registers (regno);
deprecated_child_ops.to_fetch_registers (regcache, regno);
else
{
unsigned char buf[MAX_REGISTER_SIZE];
@ -303,7 +303,7 @@ hpux_thread_fetch_registers (int regno)
else
read_memory (sp + regmap[regno], buf, register_size (current_gdbarch, regno));
regcache_raw_supply (current_regcache, regno, buf);
regcache_raw_supply (regcache, regno, buf);
}
}
@ -311,7 +311,7 @@ hpux_thread_fetch_registers (int regno)
}
static void
hpux_thread_store_registers (int regno)
hpux_thread_store_registers (struct regcache *regcache, int regno)
{
cma__t_int_tcb tcb, *tcb_ptr;
struct cleanup *old_chain;
@ -326,7 +326,7 @@ hpux_thread_store_registers (int regno)
if (tcb_ptr->state == cma__c_state_running)
{
deprecated_child_ops.to_store_registers (regno);
deprecated_child_ops.to_store_registers (regcache, regno);
do_cleanups (old_chain);
@ -347,7 +347,7 @@ hpux_thread_store_registers (int regno)
for (regno = first_regno; regno <= last_regno; regno++)
{
if (regmap[regno] == -1)
deprecated_child_ops.to_store_registers (regno);
deprecated_child_ops.to_store_registers (regcache, regno);
else
{
unsigned char buf[MAX_REGISTER_SIZE];
@ -356,10 +356,10 @@ hpux_thread_store_registers (int regno)
sp = (CORE_ADDR) tcb_ptr->static_ctx.sp - 160;
if (regno == HPPA_FLAGS_REGNUM)
deprecated_child_ops.to_store_registers (regno); /* Let lower layer handle this... */
deprecated_child_ops.to_store_registers (regcache, regno); /* Let lower layer handle this... */
else if (regno == HPPA_SP_REGNUM)
{
regcache_raw_collect (current_regcache, regno, buf);
regcache_raw_collect (regcache, regno, buf);
write_memory ((CORE_ADDR) &tcb_ptr->static_ctx.sp, buf,
register_size (current_gdbarch, regno));
tcb_ptr->static_ctx.sp
@ -367,13 +367,13 @@ hpux_thread_store_registers (int regno)
}
else if (regno == HPPA_PCOQ_HEAD_REGNUM)
{
regcache_raw_collect (current_regcache, regno, buf);
regcache_raw_collect (regcache, regno, buf);
write_memory (sp - 20, buf,
register_size (current_gdbarch, regno));
}
else
{
regcache_raw_collect (current_regcache, regno, buf);
regcache_raw_collect (regcache, regno, buf);
write_memory (sp + regmap[regno], buf,
register_size (current_gdbarch, regno));
}

80
gdb/i386-linux-nat.c
View file

@ -142,7 +142,7 @@ int have_ptrace_getfpxregs =
/* Fetch one register. */
static void
fetch_register (int regno)
fetch_register (struct regcache *regcache, int regno)
{
int tid;
int val;
@ -150,7 +150,7 @@ fetch_register (int regno)
gdb_assert (!have_ptrace_getregs);
if (regmap[regno] == -1)
{
regcache_raw_supply (current_regcache, regno, NULL);
regcache_raw_supply (regcache, regno, NULL);
return;
}
@ -165,13 +165,13 @@ fetch_register (int regno)
error (_("Couldn't read register %s (#%d): %s."), REGISTER_NAME (regno),
regno, safe_strerror (errno));
regcache_raw_supply (current_regcache, regno, &val);
regcache_raw_supply (regcache, regno, &val);
}
/* Store one register. */
static void
store_register (int regno)
store_register (const struct regcache *regcache, int regno)
{
int tid;
int val;
@ -186,7 +186,7 @@ store_register (int regno)
tid = PIDGET (inferior_ptid); /* Not a threaded program. */
errno = 0;
regcache_raw_collect (current_regcache, regno, &val);
regcache_raw_collect (regcache, regno, &val);
ptrace (PTRACE_POKEUSER, tid, 4 * regmap[regno], val);
if (errno != 0)
error (_("Couldn't write register %s (#%d): %s."), REGISTER_NAME (regno),
@ -241,7 +241,7 @@ fill_gregset (const struct regcache *regcache,
store their values in GDB's register array. */
static void
fetch_regs (int tid)
fetch_regs (struct regcache *regcache, int tid)
{
elf_gregset_t regs;
@ -258,21 +258,21 @@ fetch_regs (int tid)
perror_with_name (_("Couldn't get registers"));
}
supply_gregset (current_regcache, (const elf_gregset_t *) &regs);
supply_gregset (regcache, (const elf_gregset_t *) &regs);
}
/* Store all valid general-purpose registers in GDB's register array
into the process/thread specified by TID. */
static void
store_regs (int tid, int regno)
store_regs (const struct regcache *regcache, int tid, int regno)
{
elf_gregset_t regs;
if (ptrace (PTRACE_GETREGS, tid, 0, (int) &regs) < 0)
perror_with_name (_("Couldn't get registers"));
fill_gregset (current_regcache, &regs, regno);
fill_gregset (regcache, &regs, regno);
if (ptrace (PTRACE_SETREGS, tid, 0, (int) &regs) < 0)
perror_with_name (_("Couldn't write registers"));
@ -280,8 +280,8 @@ store_regs (int tid, int regno)
#else
static void fetch_regs (int tid) {}
static void store_regs (int tid, int regno) {}
static void fetch_regs (struct regcache *regcache, int tid) {}
static void store_regs (const struct regcache *regcache, int tid, int regno) {}
#endif
@ -314,28 +314,28 @@ fill_fpregset (const struct regcache *regcache,
thier values in GDB's register array. */
static void
fetch_fpregs (int tid)
fetch_fpregs (struct regcache *regcache, int tid)
{
elf_fpregset_t fpregs;
if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
perror_with_name (_("Couldn't get floating point status"));
supply_fpregset (current_regcache, (const elf_fpregset_t *) &fpregs);
supply_fpregset (regcache, (const elf_fpregset_t *) &fpregs);
}
/* Store all valid floating-point registers in GDB's register array
into the process/thread specified by TID. */
static void
store_fpregs (int tid, int regno)
store_fpregs (const struct regcache *regcache, int tid, int regno)
{
elf_fpregset_t fpregs;
if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
perror_with_name (_("Couldn't get floating point status"));
fill_fpregset (current_regcache, &fpregs, regno);
fill_fpregset (regcache, &fpregs, regno);
if (ptrace (PTRACE_SETFPREGS, tid, 0, (int) &fpregs) < 0)
perror_with_name (_("Couldn't write floating point status"));
@ -343,8 +343,8 @@ store_fpregs (int tid, int regno)
#else
static void fetch_fpregs (int tid) {}
static void store_fpregs (int tid, int regno) {}
static void fetch_fpregs (struct regcache *regcache, int tid) {}
static void store_fpregs (const struct regcache *regcache, int tid, int regno) {}
#endif
@ -379,7 +379,7 @@ fill_fpxregset (const struct regcache *regcache,
Return non-zero if successful, zero otherwise. */
static int
fetch_fpxregs (int tid)
fetch_fpxregs (struct regcache *regcache, int tid)
{
elf_fpxregset_t fpxregs;
@ -397,7 +397,7 @@ fetch_fpxregs (int tid)
perror_with_name (_("Couldn't read floating-point and SSE registers"));
}
supply_fpxregset (current_regcache, (const elf_fpxregset_t *) &fpxregs);
supply_fpxregset (regcache, (const elf_fpxregset_t *) &fpxregs);
return 1;
}
@ -406,7 +406,7 @@ fetch_fpxregs (int tid)
Return non-zero if successful, zero otherwise. */
static int
store_fpxregs (int tid, int regno)
store_fpxregs (const struct regcache *regcache, int tid, int regno)
{
elf_fpxregset_t fpxregs;
@ -424,7 +424,7 @@ store_fpxregs (int tid, int regno)
perror_with_name (_("Couldn't read floating-point and SSE registers"));
}
fill_fpxregset (current_regcache, &fpxregs, regno);
fill_fpxregset (regcache, &fpxregs, regno);
if (ptrace (PTRACE_SETFPXREGS, tid, 0, &fpxregs) == -1)
perror_with_name (_("Couldn't write floating-point and SSE registers"));
@ -434,8 +434,8 @@ store_fpxregs (int tid, int regno)
#else
static int fetch_fpxregs (int tid) { return 0; }
static int store_fpxregs (int tid, int regno) { return 0; }
static int fetch_fpxregs (struct regcache *regcache, int tid) { return 0; }
static int store_fpxregs (const struct regcache *regcache, int tid, int regno) { return 0; }
#endif /* HAVE_PTRACE_GETFPXREGS */
@ -447,7 +447,7 @@ static int store_fpxregs (int tid, int regno) { return 0; }
registers). */
static void
i386_linux_fetch_inferior_registers (int regno)
i386_linux_fetch_inferior_registers (struct regcache *regcache, int regno)
{
int tid;
@ -459,7 +459,7 @@ i386_linux_fetch_inferior_registers (int regno)
for (i = 0; i < NUM_REGS; i++)
if (regno == -1 || regno == i)
fetch_register (i);
fetch_register (regcache, i);
return;
}
@ -475,30 +475,30 @@ i386_linux_fetch_inferior_registers (int regno)
zero. */
if (regno == -1)
{
fetch_regs (tid);
fetch_regs (regcache, tid);
/* The call above might reset `have_ptrace_getregs'. */
if (!have_ptrace_getregs)
{
i386_linux_fetch_inferior_registers (regno);
i386_linux_fetch_inferior_registers (regcache, regno);
return;
}
if (fetch_fpxregs (tid))
if (fetch_fpxregs (regcache, tid))
return;
fetch_fpregs (tid);
fetch_fpregs (regcache, tid);
return;
}
if (GETREGS_SUPPLIES (regno))
{
fetch_regs (tid);
fetch_regs (regcache, tid);
return;
}
if (GETFPXREGS_SUPPLIES (regno))
{
if (fetch_fpxregs (tid))
if (fetch_fpxregs (regcache, tid))
return;
/* Either our processor or our kernel doesn't support the SSE
@ -507,7 +507,7 @@ i386_linux_fetch_inferior_registers (int regno)
more graceful to handle differences in the register set using
gdbarch. Until then, this will at least make things work
plausibly. */
fetch_fpregs (tid);
fetch_fpregs (regcache, tid);
return;
}
@ -519,7 +519,7 @@ i386_linux_fetch_inferior_registers (int regno)
do this for all registers (including the floating point and SSE
registers). */
static void
i386_linux_store_inferior_registers (int regno)
i386_linux_store_inferior_registers (struct regcache *regcache, int regno)
{
int tid;
@ -531,7 +531,7 @@ i386_linux_store_inferior_registers (int regno)
for (i = 0; i < NUM_REGS; i++)
if (regno == -1 || regno == i)
store_register (i);
store_register (regcache, i);
return;
}
@ -546,28 +546,28 @@ i386_linux_store_inferior_registers (int regno)
store_fpxregs can fail, and return zero. */
if (regno == -1)
{
store_regs (tid, regno);
if (store_fpxregs (tid, regno))
store_regs (regcache, tid, regno);
if (store_fpxregs (regcache, tid, regno))
return;
store_fpregs (tid, regno);
store_fpregs (regcache, tid, regno);
return;
}
if (GETREGS_SUPPLIES (regno))
{
store_regs (tid, regno);
store_regs (regcache, tid, regno);
return;
}
if (GETFPXREGS_SUPPLIES (regno))
{
if (store_fpxregs (tid, regno))
if (store_fpxregs (regcache, tid, regno))
return;
/* Either our processor or our kernel doesn't support the SSE
registers, so just write the FP registers in the traditional
way. */
store_fpregs (tid, regno);
store_fpregs (regcache, tid, regno);
return;
}

18
gdb/i386bsd-nat.c
View file

@ -132,7 +132,7 @@ i386bsd_collect_gregset (const struct regcache *regcache,
for all registers (including the floating point registers). */
static void
i386bsd_fetch_inferior_registers (int regnum)
i386bsd_fetch_inferior_registers (struct regcache *regcache, int regnum)
{
if (regnum == -1 || GETREGS_SUPPLIES (regnum))
{
@ -142,7 +142,7 @@ i386bsd_fetch_inferior_registers (int regnum)
(PTRACE_TYPE_ARG3) &regs, 0) == -1)
perror_with_name (_("Couldn't get registers"));
i386bsd_supply_gregset (current_regcache, &regs);
i386bsd_supply_gregset (regcache, &regs);
if (regnum != -1)
return;
}
@ -158,7 +158,7 @@ i386bsd_fetch_inferior_registers (int regnum)
(PTRACE_TYPE_ARG3) xmmregs, 0) == 0)
{
have_ptrace_xmmregs = 1;
i387_supply_fxsave (current_regcache, -1, xmmregs);
i387_supply_fxsave (regcache, -1, xmmregs);
}
else
{
@ -166,14 +166,14 @@ i386bsd_fetch_inferior_registers (int regnum)
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
perror_with_name (_("Couldn't get floating point status"));
i387_supply_fsave (current_regcache, -1, &fpregs);
i387_supply_fsave (regcache, -1, &fpregs);
}
#else
if (ptrace (PT_GETFPREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
perror_with_name (_("Couldn't get floating point status"));
i387_supply_fsave (current_regcache, -1, &fpregs);
i387_supply_fsave (regcache, -1, &fpregs);
#endif
}
}
@ -182,7 +182,7 @@ i386bsd_fetch_inferior_registers (int regnum)
this for all registers (including the floating point registers). */
static void
i386bsd_store_inferior_registers (int regnum)
i386bsd_store_inferior_registers (struct regcache *regcache, int regnum)
{
if (regnum == -1 || GETREGS_SUPPLIES (regnum))
{
@ -192,7 +192,7 @@ i386bsd_store_inferior_registers (int regnum)
(PTRACE_TYPE_ARG3) &regs, 0) == -1)
perror_with_name (_("Couldn't get registers"));
i386bsd_collect_gregset (current_regcache, &regs, regnum);
i386bsd_collect_gregset (regcache, &regs, regnum);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &regs, 0) == -1)
@ -214,7 +214,7 @@ i386bsd_store_inferior_registers (int regnum)
{
have_ptrace_xmmregs = 1;
i387_collect_fxsave (current_regcache, regnum, xmmregs);
i387_collect_fxsave (regcache, regnum, xmmregs);
if (ptrace (PT_SETXMMREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) xmmregs, 0) == -1)
@ -228,7 +228,7 @@ i386bsd_store_inferior_registers (int regnum)
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
perror_with_name (_("Couldn't get floating point status"));
i387_collect_fsave (current_regcache, regnum, &fpregs);
i387_collect_fsave (regcache, regnum, &fpregs);
if (ptrace (PT_SETFPREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)

23
gdb/i386gnu-nat.c
View file

@ -66,7 +66,7 @@ static int reg_offset[] =
of the corresponding (pseudo) registers. */
static void
fetch_fpregs (struct proc *thread)
fetch_fpregs (struct regcache *regcache, struct proc *thread)
{
mach_msg_type_number_t count = i386_FLOAT_STATE_COUNT;
struct i386_float_state state;
@ -84,12 +84,12 @@ fetch_fpregs (struct proc *thread)
if (!state.initialized)
{
/* The floating-point state isn't initialized. */
i387_supply_fsave (current_regcache, -1, NULL);
i387_supply_fsave (regcache, -1, NULL);
}
else
{
/* Supply the floating-point registers. */
i387_supply_fsave (current_regcache, -1, state.hw_state);
i387_supply_fsave (regcache, -1, state.hw_state);
}
}
@ -113,7 +113,7 @@ supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregs)
/* Fetch register REGNO, or all regs if REGNO is -1. */
void
gnu_fetch_registers (int regno)
gnu_fetch_registers (struct regcache *regcache, int regno)
{
struct proc *thread;
@ -145,14 +145,14 @@ gnu_fetch_registers (int regno)
proc_debug (thread, "fetching all register");
for (i = 0; i < I386_NUM_GREGS; i++)
regcache_raw_supply (current_regcache, i, REG_ADDR (state, i));
regcache_raw_supply (regcache, i, REG_ADDR (state, i));
thread->fetched_regs = ~0;
}
else
{
proc_debug (thread, "fetching register %s", REGISTER_NAME (regno));
regcache_raw_supply (current_regcache, regno,
regcache_raw_supply (regcache, regno,
REG_ADDR (state, regno));
thread->fetched_regs |= (1 << regno);
}
@ -162,7 +162,7 @@ gnu_fetch_registers (int regno)
{
proc_debug (thread, "fetching floating-point registers");
fetch_fpregs (thread);
fetch_fpregs (regcache, thread);
}
}
@ -170,7 +170,7 @@ gnu_fetch_registers (int regno)
/* Store the whole floating-point state into THREAD using information
from the corresponding (pseudo) registers. */
static void
store_fpregs (struct proc *thread, int regno)
store_fpregs (const struct regcache *regcache, struct proc *thread, int regno)
{
mach_msg_type_number_t count = i386_FLOAT_STATE_COUNT;
struct i386_float_state state;
@ -187,7 +187,7 @@ store_fpregs (struct proc *thread, int regno)
/* FIXME: kettenis/2001-07-15: Is this right? Should we somehow
take into account DEPRECATED_REGISTER_VALID like the old code did? */
i387_collect_fsave (current_regcache, regno, state.hw_state);
i387_collect_fsave (regcache, regno, state.hw_state);
err = thread_set_state (thread->port, i386_FLOAT_STATE,
(thread_state_t) &state, i386_FLOAT_STATE_COUNT);
@ -201,9 +201,8 @@ store_fpregs (struct proc *thread, int regno)
/* Store at least register REGNO, or all regs if REGNO == -1. */
void
gnu_store_registers (int regno)
gnu_store_registers (struct regcache *regcache, int regno)
{
struct regcache *regcache = current_regcache;
struct proc *thread;
/* Make sure we know about new threads. */
@ -286,6 +285,6 @@ gnu_store_registers (int regno)
{
proc_debug (thread, "storing floating-point registers");
store_fpregs (thread, regno);
store_fpregs (regcache, thread, regno);
}
}

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

@ -666,7 +666,7 @@ ia64_linux_can_use_hw_breakpoint (int type, int cnt, int othertype)
/* Fetch register REGNUM from the inferior. */
static void
ia64_linux_fetch_register (int regnum)
ia64_linux_fetch_register (struct regcache *regcache, int regnum)
{
CORE_ADDR addr;
size_t size;
@ -675,7 +675,7 @@ ia64_linux_fetch_register (int regnum)
if (ia64_cannot_fetch_register (regnum))
{
regcache_raw_supply (current_regcache, regnum, NULL);
regcache_raw_supply (regcache, regnum, NULL);
return;
}
@ -703,26 +703,26 @@ ia64_linux_fetch_register (int regnum)
addr += sizeof (PTRACE_TYPE_RET);
}
regcache_raw_supply (current_regcache, regnum, buf);
regcache_raw_supply (regcache, regnum, buf);
}
/* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
for all registers. */
static void
ia64_linux_fetch_registers (int regnum)
ia64_linux_fetch_registers (struct regcache *regcache, int regnum)
{
if (regnum == -1)
for (regnum = 0; regnum < NUM_REGS; regnum++)
ia64_linux_fetch_register (regnum);
ia64_linux_fetch_register (regcache, regnum);
else
ia64_linux_fetch_register (regnum);
ia64_linux_fetch_register (regcache, regnum);
}
/* Store register REGNUM into the inferior. */
static void
ia64_linux_store_register (int regnum)
ia64_linux_store_register (const struct regcache *regcache, int regnum)
{
CORE_ADDR addr;
size_t size;
@ -746,7 +746,7 @@ ia64_linux_store_register (int regnum)
buf = alloca (size);
/* Write the register contents into the inferior a chunk at a time. */
regcache_raw_collect (current_regcache, regnum, buf);
regcache_raw_collect (regcache, regnum, buf);
for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
{
errno = 0;
@ -763,13 +763,13 @@ ia64_linux_store_register (int regnum)
this for all registers. */
static void
ia64_linux_store_registers (int regnum)
ia64_linux_store_registers (struct regcache *regcache, int regnum)
{
if (regnum == -1)
for (regnum = 0; regnum < NUM_REGS; regnum++)
ia64_linux_store_register (regnum);
ia64_linux_store_register (regcache, regnum);
else
ia64_linux_store_register (regnum);
ia64_linux_store_register (regcache, regnum);
}

2
gdb/ia64-tdep.c
View file

@ -3540,7 +3540,7 @@ ia64_store_return_value (struct type *type, struct regcache *regcache,
char to[MAX_REGISTER_SIZE];
convert_typed_floating (valbuf, type, to, builtin_type_ia64_ext);
regcache_cooked_write (regcache, IA64_FR8_REGNUM, (void *)to);
target_store_registers (IA64_FR8_REGNUM);
target_store_registers (regcache, IA64_FR8_REGNUM);
}
else
regcache_cooked_write (regcache, IA64_GR8_REGNUM, valbuf);

8
gdb/inf-child.c
View file

@ -33,22 +33,22 @@
for all registers. */
static void
inf_child_fetch_inferior_registers (int regnum)
inf_child_fetch_inferior_registers (struct regcache *regcache, int regnum)
{
if (regnum == -1)
{
for (regnum = 0; regnum < NUM_REGS; regnum++)
regcache_raw_supply (current_regcache, regnum, NULL);
regcache_raw_supply (regcache, regnum, NULL);
}
else
regcache_raw_supply (current_regcache, regnum, NULL);
regcache_raw_supply (regcache, regnum, NULL);
}
/* Store register REGNUM back into the inferior. If REGNUM is -1, do
this for all registers (including the floating point registers). */
static void
inf_child_store_inferior_registers (int regnum)
inf_child_store_inferior_registers (struct regcache *regcache, int regnum)
{
}

22
gdb/inf-ptrace.c
View file

@ -617,7 +617,7 @@ static CORE_ADDR (*inf_ptrace_register_u_offset)(int);
/* Fetch register REGNUM from the inferior. */
static void
inf_ptrace_fetch_register (int regnum)
inf_ptrace_fetch_register (struct regcache *regcache, int regnum)
{
CORE_ADDR addr;
size_t size;
@ -626,7 +626,7 @@ inf_ptrace_fetch_register (int regnum)
if (CANNOT_FETCH_REGISTER (regnum))
{
regcache_raw_supply (current_regcache, regnum, NULL);
regcache_raw_supply (regcache, regnum, NULL);
return;
}
@ -654,26 +654,26 @@ inf_ptrace_fetch_register (int regnum)
addr += sizeof (PTRACE_TYPE_RET);
}
regcache_raw_supply (current_regcache, regnum, buf);
regcache_raw_supply (regcache, regnum, buf);
}
/* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
for all registers. */
static void
inf_ptrace_fetch_registers (int regnum)
inf_ptrace_fetch_registers (struct regcache *regcache, int regnum)
{
if (regnum == -1)
for (regnum = 0; regnum < NUM_REGS; regnum++)
inf_ptrace_fetch_register (regnum);
inf_ptrace_fetch_register (regcache, regnum);
else
inf_ptrace_fetch_register (regnum);
inf_ptrace_fetch_register (regcache, regnum);
}
/* Store register REGNUM into the inferior. */
static void
inf_ptrace_store_register (int regnum)
inf_ptrace_store_register (const struct regcache *regcache, int regnum)
{
CORE_ADDR addr;
size_t size;
@ -697,7 +697,7 @@ inf_ptrace_store_register (int regnum)
buf = alloca (size);
/* Write the register contents into the inferior a chunk at a time. */
regcache_raw_collect (current_regcache, regnum, buf);
regcache_raw_collect (regcache, regnum, buf);
for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
{
errno = 0;
@ -714,13 +714,13 @@ inf_ptrace_store_register (int regnum)
this for all registers. */
void
inf_ptrace_store_registers (int regnum)
inf_ptrace_store_registers (struct regcache *regcache, int regnum)
{
if (regnum == -1)
for (regnum = 0; regnum < NUM_REGS; regnum++)
inf_ptrace_store_register (regnum);
inf_ptrace_store_register (regcache, regnum);
else
inf_ptrace_store_register (regnum);
inf_ptrace_store_register (regcache, regnum);
}
/* Create a "traditional" ptrace target. REGISTER_U_OFFSET should be

4
gdb/inferior.h
View file

@ -209,9 +209,9 @@ extern void default_print_registers_info (struct gdbarch *gdbarch,
struct frame_info *frame,
int regnum, int all);
extern void store_inferior_registers (int);
extern void store_inferior_registers (struct regcache *, int);
extern void fetch_inferior_registers (int);
extern void fetch_inferior_registers (struct regcache *, int);
extern void child_terminal_info (char *, int);

22
gdb/infptrace.c
View file

@ -203,7 +203,7 @@ detach (int signal)
/* Fetch register REGNUM from the inferior. */
static void
fetch_register (int regnum)
fetch_register (struct regcache *regcache, int regnum)
{
CORE_ADDR addr;
size_t size;
@ -212,7 +212,7 @@ fetch_register (int regnum)
if (CANNOT_FETCH_REGISTER (regnum))
{
regcache_raw_supply (current_regcache, regnum, NULL);
regcache_raw_supply (regcache, regnum, NULL);
return;
}
@ -239,26 +239,26 @@ fetch_register (int regnum)
addr += sizeof (PTRACE_TYPE_RET);
}
regcache_raw_supply (current_regcache, regnum, buf);
regcache_raw_supply (regcache, regnum, buf);
}
/* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
for all registers. */
void
fetch_inferior_registers (int regnum)
fetch_inferior_registers (struct regcache *regcache, int regnum)
{
if (regnum == -1)
for (regnum = 0; regnum < NUM_REGS; regnum++)
fetch_register (regnum);
fetch_register (regcache, regnum);
else
fetch_register (regnum);
fetch_register (regcache, regnum);
}
/* Store register REGNUM into the inferior. */
static void
store_register (int regnum)
store_register (const struct regcache *regcache, int regnum)
{
CORE_ADDR addr;
size_t size;
@ -281,7 +281,7 @@ store_register (int regnum)
buf = alloca (size);
/* Write the register contents into the inferior a chunk at the time. */
regcache_raw_collect (current_regcache, regnum, buf);
regcache_raw_collect (regcache, regnum, buf);
for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
{
errno = 0;
@ -298,13 +298,13 @@ store_register (int regnum)
this for all registers (including the floating point registers). */
void
store_inferior_registers (int regnum)
store_inferior_registers (struct regcache *regcache, int regnum)
{
if (regnum == -1)
for (regnum = 0; regnum < NUM_REGS; regnum++)
store_register (regnum);
store_register (regcache, regnum);
else
store_register (regnum);
store_register (regcache, regnum);
}
#endif /* not FETCH_INFERIOR_REGISTERS. */

13
gdb/linux-nat.c
View file

@ -2650,8 +2650,8 @@ linux_nat_corefile_thread_callback (struct lwp_info *ti, void *data)
inferior_ptid = ti->ptid;
registers_changed ();
target_fetch_registers (-1); /* FIXME should not be necessary;
fill_gregset should do it automatically. */
/* FIXME should not be necessary; fill_gregset should do it automatically. */
target_fetch_registers (current_regcache, -1);
args->note_data = linux_nat_do_thread_registers (args->obfd,
ti->ptid,
args->note_data,
@ -2659,8 +2659,9 @@ linux_nat_corefile_thread_callback (struct lwp_info *ti, void *data)
args->num_notes++;
inferior_ptid = saved_ptid;
registers_changed ();
target_fetch_registers (-1); /* FIXME should not be necessary;
fill_gregset should do it automatically. */
/* FIXME should not be necessary; fill_gregset should do it automatically. */
target_fetch_registers (current_regcache, -1);
return 0;
}
@ -2671,8 +2672,8 @@ linux_nat_do_registers (bfd *obfd, ptid_t ptid,
char *note_data, int *note_size)
{
registers_changed ();
target_fetch_registers (-1); /* FIXME should not be necessary;
fill_gregset should do it automatically. */
/* FIXME should not be necessary; fill_gregset should do it automatically. */
target_fetch_registers (current_regcache, -1);
return linux_nat_do_thread_registers (obfd,
ptid_build (ptid_get_pid (inferior_ptid),
ptid_get_pid (inferior_ptid),

16
gdb/m32r-linux-nat.c
View file

@ -108,14 +108,14 @@ supply_gregset (struct regcache *regcache, const elf_gregset_t * gregsetp)
store their values in GDB's register array. */
static void
fetch_regs (int tid)
fetch_regs (struct regcache *regcache, int tid)
{
elf_gregset_t regs;
if (ptrace (PTRACE_GETREGS, tid, 0, (int) &regs) < 0)
perror_with_name (_("Couldn't get registers"));
supply_gregset (current_regcache, (const elf_gregset_t *) &regs);
supply_gregset (regcache, (const elf_gregset_t *) &regs);
}
/* Fill register REGNO (if it is a general-purpose register) in
@ -157,14 +157,14 @@ fill_gregset (const struct regcache *regcache,
into the process/thread specified by TID. */
static void
store_regs (int tid, int regno)
store_regs (const struct regcache *regcache, int tid, int regno)
{
elf_gregset_t regs;
if (ptrace (PTRACE_GETREGS, tid, 0, (int) &regs) < 0)
perror_with_name (_("Couldn't get registers"));
fill_gregset (current_regcache, &regs, regno);
fill_gregset (regcache, &regs, regno);
if (ptrace (PTRACE_SETREGS, tid, 0, (int) &regs) < 0)
perror_with_name (_("Couldn't write registers"));
@ -195,7 +195,7 @@ fill_fpregset (const struct regcache *regcache,
registers). */
static void
m32r_linux_fetch_inferior_registers (int regno)
m32r_linux_fetch_inferior_registers (struct regcache *regcache, int regno)
{
int tid;
@ -209,7 +209,7 @@ m32r_linux_fetch_inferior_registers (int regno)
results. */
if (regno == -1 || GETREGS_SUPPLIES (regno))
{
fetch_regs (tid);
fetch_regs (regcache, tid);
return;
}
@ -221,7 +221,7 @@ m32r_linux_fetch_inferior_registers (int regno)
do this for all registers (including the floating point and SSE
registers). */
static void
m32r_linux_store_inferior_registers (int regno)
m32r_linux_store_inferior_registers (struct regcache *regcache, int regno)
{
int tid;
@ -233,7 +233,7 @@ m32r_linux_store_inferior_registers (int regno)
transfers more registers in one system call. */
if (regno == -1 || GETREGS_SUPPLIES (regno))
{
store_regs (tid, regno);
store_regs (regcache, tid, regno);
return;
}

12
gdb/m68kbsd-nat.c
View file

@ -108,7 +108,7 @@ m68kbsd_collect_fpregset (struct regcache *regcache,
for all registers (including the floating-point registers). */
static void
m68kbsd_fetch_inferior_registers (int regnum)
m68kbsd_fetch_inferior_registers (struct regcache *regcache, int regnum)
{
if (regnum == -1 || m68kbsd_gregset_supplies_p (regnum))
{
@ -118,7 +118,7 @@ m68kbsd_fetch_inferior_registers (int regnum)
(PTRACE_TYPE_ARG3) &regs, 0) == -1)
perror_with_name (_("Couldn't get registers"));
m68kbsd_supply_gregset (current_regcache, &regs);
m68kbsd_supply_gregset (regcache, &regs);
}
if (regnum == -1 || m68kbsd_fpregset_supplies_p (regnum))
@ -129,7 +129,7 @@ m68kbsd_fetch_inferior_registers (int regnum)
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
perror_with_name (_("Couldn't get floating point status"));
m68kbsd_supply_fpregset (current_regcache, &fpregs);
m68kbsd_supply_fpregset (regcache, &fpregs);
}
}
@ -137,7 +137,7 @@ m68kbsd_fetch_inferior_registers (int regnum)
this for all registers (including the floating-point registers). */
static void
m68kbsd_store_inferior_registers (int regnum)
m68kbsd_store_inferior_registers (struct regcache *regcache, int regnum)
{
if (regnum == -1 || m68kbsd_gregset_supplies_p (regnum))
{
@ -147,7 +147,7 @@ m68kbsd_store_inferior_registers (int regnum)
(PTRACE_TYPE_ARG3) &regs, 0) == -1)
perror_with_name (_("Couldn't get registers"));
m68kbsd_collect_gregset (current_regcache, &regs, regnum);
m68kbsd_collect_gregset (regcache, &regs, regnum);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &regs, 0) == -1)
@ -162,7 +162,7 @@ m68kbsd_store_inferior_registers (int regnum)
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
perror_with_name (_("Couldn't get floating point status"));
m68kbsd_collect_fpregset (current_regcache, &fpregs, regnum);
m68kbsd_collect_fpregset (regcache, &fpregs, regnum);
if (ptrace (PT_SETFPREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)

72
gdb/m68klinux-nat.c
View file

@ -114,7 +114,7 @@ int have_ptrace_getregs =
/* Fetch one register. */
static void
fetch_register (int regno)
fetch_register (struct regcache *regcache, int regno)
{
/* This isn't really an address. But ptrace thinks of it as one. */
CORE_ADDR regaddr;
@ -126,7 +126,7 @@ fetch_register (int regno)
if (CANNOT_FETCH_REGISTER (regno))
{
memset (buf, '\0', register_size (current_gdbarch, regno)); /* Supply zeroes */
regcache_raw_supply (current_regcache, regno, buf);
regcache_raw_supply (regcache, regno, buf);
return;
}
@ -150,7 +150,7 @@ fetch_register (int regno)
perror_with_name (mess);
}
}
regcache_raw_supply (current_regcache, regno, buf);
regcache_raw_supply (regcache, regno, buf);
}
/* Fetch register values from the inferior.
@ -158,17 +158,17 @@ fetch_register (int regno)
Otherwise, REGNO specifies which register (so we can save time). */
static void
old_fetch_inferior_registers (int regno)
old_fetch_inferior_registers (struct regcache *regcache, int regno)
{
if (regno >= 0)
{
fetch_register (regno);
fetch_register (regcache, regno);
}
else
{
for (regno = 0; regno < NUM_REGS; regno++)
{
fetch_register (regno);
fetch_register (regcache, regno);
}
}
}
@ -176,7 +176,7 @@ old_fetch_inferior_registers (int regno)
/* Store one register. */
static void
store_register (int regno)
store_register (const struct regcache *regcache, int regno)
{
/* This isn't really an address. But ptrace thinks of it as one. */
CORE_ADDR regaddr;
@ -198,7 +198,7 @@ store_register (int regno)
regaddr = 4 * regmap[regno];
/* Put the contents of regno into a local buffer */
regcache_raw_collect (current_regcache, regno, buf);
regcache_raw_collect (regcache, regno, buf);
/* Store the local buffer into the inferior a chunk at the time. */
for (i = 0; i < register_size (current_gdbarch, regno);
@ -222,17 +222,17 @@ store_register (int regno)
Otherwise, REGNO specifies which register (so we can save time). */
static void
old_store_inferior_registers (int regno)
old_store_inferior_registers (const struct regcache *regcache, int regno)
{
if (regno >= 0)
{
store_register (regno);
store_register (regcache, regno);
}
else
{
for (regno = 0; regno < NUM_REGS; regno++)
{
store_register (regno);
store_register (regcache, regno);
}
}
}
@ -274,7 +274,7 @@ fill_gregset (const struct regcache *regcache,
store their values in GDB's register array. */
static void
fetch_regs (int tid)
fetch_regs (struct regcache *regcache, int tid)
{
elf_gregset_t regs;
@ -291,21 +291,21 @@ fetch_regs (int tid)
perror_with_name (_("Couldn't get registers"));
}
supply_gregset (current_regcache, (const elf_gregset_t *) &regs);
supply_gregset (regcache, (const elf_gregset_t *) &regs);
}
/* Store all valid general-purpose registers in GDB's register array
into the process/thread specified by TID. */
static void
store_regs (int tid, int regno)
store_regs (const struct regcache *regcache, int tid, int regno)
{
elf_gregset_t regs;
if (ptrace (PTRACE_GETREGS, tid, 0, (int) &regs) < 0)
perror_with_name (_("Couldn't get registers"));
fill_gregset (current_regcache, &regs, regno);
fill_gregset (regcache, &regs, regno);
if (ptrace (PTRACE_SETREGS, tid, 0, (int) &regs) < 0)
perror_with_name (_("Couldn't write registers"));
@ -313,8 +313,8 @@ store_regs (int tid, int regno)
#else
static void fetch_regs (int tid) {}
static void store_regs (int tid, int regno) {}
static void fetch_regs (struct regcache *regcache, int tid) {}
static void store_regs (const struct regcache *regcache, int tid, int regno) {}
#endif
@ -369,28 +369,28 @@ fill_fpregset (const struct regcache *regcache,
thier values in GDB's register array. */
static void
fetch_fpregs (int tid)
fetch_fpregs (struct regcache *regcache, int tid)
{
elf_fpregset_t fpregs;
if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
perror_with_name (_("Couldn't get floating point status"));
supply_fpregset (current_regcache, (const elf_fpregset_t *) &fpregs);
supply_fpregset (regcache, (const elf_fpregset_t *) &fpregs);
}
/* Store all valid floating-point registers in GDB's register array
into the process/thread specified by TID. */
static void
store_fpregs (int tid, int regno)
store_fpregs (const struct regcache *regcache, int tid, int regno)
{
elf_fpregset_t fpregs;
if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
perror_with_name (_("Couldn't get floating point status"));
fill_fpregset (current_regcache, &fpregs, regno);
fill_fpregset (regcache, &fpregs, regno);
if (ptrace (PTRACE_SETFPREGS, tid, 0, (int) &fpregs) < 0)
perror_with_name (_("Couldn't write floating point status"));
@ -398,8 +398,8 @@ store_fpregs (int tid, int regno)
#else
static void fetch_fpregs (int tid) {}
static void store_fpregs (int tid, int regno) {}
static void fetch_fpregs (struct regcache *regcache, int tid) {}
static void store_fpregs (const struct regcache *regcache, int tid, int regno) {}
#endif
@ -410,7 +410,7 @@ static void store_fpregs (int tid, int regno) {}
registers). */
static void
m68k_linux_fetch_inferior_registers (int regno)
m68k_linux_fetch_inferior_registers (struct regcache *regcache, int regno)
{
int tid;
@ -418,7 +418,7 @@ m68k_linux_fetch_inferior_registers (int regno)
GETREGS request isn't available. */
if (! have_ptrace_getregs)
{
old_fetch_inferior_registers (regno);
old_fetch_inferior_registers (regcache, regno);
return;
}
@ -433,28 +433,28 @@ m68k_linux_fetch_inferior_registers (int regno)
zero. */
if (regno == -1)
{
fetch_regs (tid);
fetch_regs (regcache, tid);
/* The call above might reset `have_ptrace_getregs'. */
if (! have_ptrace_getregs)
{
old_fetch_inferior_registers (-1);
old_fetch_inferior_registers (regcache, -1);
return;
}
fetch_fpregs (tid);
fetch_fpregs (regcache, tid);
return;
}
if (getregs_supplies (regno))
{
fetch_regs (tid);
fetch_regs (regcache, tid);
return;
}
if (getfpregs_supplies (regno))
{
fetch_fpregs (tid);
fetch_fpregs (regcache, tid);
return;
}
@ -466,7 +466,7 @@ m68k_linux_fetch_inferior_registers (int regno)
do this for all registers (including the floating point and SSE
registers). */
static void
m68k_linux_store_inferior_registers (int regno)
m68k_linux_store_inferior_registers (struct regcache *regcache, int regno)
{
int tid;
@ -474,7 +474,7 @@ m68k_linux_store_inferior_registers (int regno)
SETREGS request isn't available. */
if (! have_ptrace_getregs)
{
old_store_inferior_registers (regno);
old_store_inferior_registers (regcache, regno);
return;
}
@ -488,20 +488,20 @@ m68k_linux_store_inferior_registers (int regno)
store_fpregs can fail, and return zero. */
if (regno == -1)
{
store_regs (tid, regno);
store_fpregs (tid, regno);
store_regs (regcache, tid, regno);
store_fpregs (regcache, tid, regno);
return;
}
if (getregs_supplies (regno))
{
store_regs (tid, regno);
store_regs (regcache, tid, regno);
return;
}
if (getfpregs_supplies (regno))
{
store_fpregs (tid, regno);
store_fpregs (regcache, tid, regno);
return;
}

8
gdb/m88kbsd-nat.c
View file

@ -65,7 +65,7 @@ m88kbsd_collect_gregset (const struct regcache *regcache,
for all registers. */
static void
m88kbsd_fetch_inferior_registers (int regnum)
m88kbsd_fetch_inferior_registers (struct regcache *regcache, int regnum)
{
struct reg regs;
@ -73,14 +73,14 @@ m88kbsd_fetch_inferior_registers (int regnum)
(PTRACE_TYPE_ARG3) &regs, 0) == -1)
perror_with_name (_("Couldn't get registers"));
m88kbsd_supply_gregset (current_regcache, &regs);
m88kbsd_supply_gregset (regcache, &regs);
}
/* Store register REGNUM back into the inferior. If REGNUM is -1, do
this for all registers. */
static void
m88kbsd_store_inferior_registers (int regnum)
m88kbsd_store_inferior_registers (struct regcache *regcache, int regnum)
{
struct reg regs;
@ -88,7 +88,7 @@ m88kbsd_store_inferior_registers (int regnum)
(PTRACE_TYPE_ARG3) &regs, 0) == -1)
perror_with_name (_("Couldn't get registers"));
m88kbsd_collect_gregset (current_regcache, &regs, regnum);
m88kbsd_collect_gregset (regcache, &regs, regnum);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &regs, 0) == -1)

28
gdb/mips-linux-nat.c
View file

@ -44,8 +44,8 @@ static int have_ptrace_regsets = 1;
/* Saved function pointers to fetch and store a single register using
PTRACE_PEEKUSER and PTRACE_POKEUSER. */
void (*super_fetch_registers) (int);
void (*super_store_registers) (int);
void (*super_fetch_registers) (struct regcache *, int);
void (*super_store_registers) (struct regcache *, int);
/* Pseudo registers can not be read. ptrace does not provide a way to
read (or set) MIPS_PS_REGNUM, and there's no point in reading or
@ -219,7 +219,7 @@ fill_fpregset (const struct regcache *regcache,
using PTRACE_GETREGS et al. */
static void
mips64_linux_regsets_fetch_registers (int regno)
mips64_linux_regsets_fetch_registers (struct regcache *regcache, int regno)
{
int is_fp;
int tid;
@ -252,7 +252,7 @@ mips64_linux_regsets_fetch_registers (int regno)
perror_with_name (_("Couldn't get registers"));
}
mips64_supply_gregset (current_regcache,
mips64_supply_gregset (regcache,
(const mips64_elf_gregset_t *) &regs);
}
@ -271,7 +271,7 @@ mips64_linux_regsets_fetch_registers (int regno)
perror_with_name (_("Couldn't get FP registers"));
}
mips64_supply_fpregset (current_regcache,
mips64_supply_fpregset (regcache,
(const mips64_elf_fpregset_t *) &fp_regs);
}
}
@ -280,7 +280,7 @@ mips64_linux_regsets_fetch_registers (int regno)
using PTRACE_SETREGS et al. */
static void
mips64_linux_regsets_store_registers (int regno)
mips64_linux_regsets_store_registers (const struct regcache *regcache, int regno)
{
int is_fp;
int tid;
@ -306,7 +306,7 @@ mips64_linux_regsets_store_registers (int regno)
if (ptrace (PTRACE_GETREGS, tid, 0L, (PTRACE_TYPE_ARG3) &regs) == -1)
perror_with_name (_("Couldn't get registers"));
mips64_fill_gregset (current_regcache, &regs, regno);
mips64_fill_gregset (regcache, &regs, regno);
if (ptrace (PTRACE_SETREGS, tid, 0L, (PTRACE_TYPE_ARG3) &regs) == -1)
perror_with_name (_("Couldn't set registers"));
@ -320,7 +320,7 @@ mips64_linux_regsets_store_registers (int regno)
(PTRACE_TYPE_ARG3) &fp_regs) == -1)
perror_with_name (_("Couldn't get FP registers"));
mips64_fill_fpregset (current_regcache, &fp_regs, regno);
mips64_fill_fpregset (regcache, &fp_regs, regno);
if (ptrace (PTRACE_SETFPREGS, tid, 0L,
(PTRACE_TYPE_ARG3) &fp_regs) == -1)
@ -332,32 +332,32 @@ mips64_linux_regsets_store_registers (int regno)
using any working method. */
static void
mips64_linux_fetch_registers (int regnum)
mips64_linux_fetch_registers (struct regcache *regcache, int regnum)
{
/* Unless we already know that PTRACE_GETREGS does not work, try it. */
if (have_ptrace_regsets)
mips64_linux_regsets_fetch_registers (regnum);
mips64_linux_regsets_fetch_registers (regcache, regnum);
/* If we know, or just found out, that PTRACE_GETREGS does not work, fall
back to PTRACE_PEEKUSER. */
if (!have_ptrace_regsets)
super_fetch_registers (regnum);
super_fetch_registers (regcache, regnum);
}
/* Store REGNO (or all registers if REGNO == -1) to the target
using any working method. */
static void
mips64_linux_store_registers (int regnum)
mips64_linux_store_registers (struct regcache *regcache, int regnum)
{
/* Unless we already know that PTRACE_GETREGS does not work, try it. */
if (have_ptrace_regsets)
mips64_linux_regsets_store_registers (regnum);
mips64_linux_regsets_store_registers (regcache, regnum);
/* If we know, or just found out, that PTRACE_GETREGS does not work, fall
back to PTRACE_PEEKUSER. */
if (!have_ptrace_regsets)
super_store_registers (regnum);
super_store_registers (regcache, regnum);
}
/* Return the address in the core dump or inferior of register

8
gdb/mips64obsd-nat.c
View file

@ -79,7 +79,7 @@ mips64obsd_collect_gregset (const struct regcache *regcache,
for all registers. */
static void
mips64obsd_fetch_inferior_registers (int regnum)
mips64obsd_fetch_inferior_registers (struct regcache *regcache, int regnum)
{
struct reg regs;
@ -87,14 +87,14 @@ mips64obsd_fetch_inferior_registers (int regnum)
(PTRACE_TYPE_ARG3) &regs, 0) == -1)
perror_with_name (_("Couldn't get registers"));
mips64obsd_supply_gregset (current_regcache, &regs);
mips64obsd_supply_gregset (regcache, &regs);
}
/* Store register REGNUM back into the inferior. If REGNUM is -1, do
this for all registers. */
static void
mips64obsd_store_inferior_registers (int regnum)
mips64obsd_store_inferior_registers (struct regcache *regcache, int regnum)
{
struct reg regs;
@ -102,7 +102,7 @@ mips64obsd_store_inferior_registers (int regnum)
(PTRACE_TYPE_ARG3) &regs, 0) == -1)
perror_with_name (_("Couldn't get registers"));
mips64obsd_collect_gregset (current_regcache, &regs, regnum);
mips64obsd_collect_gregset (regcache, &regs, regnum);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &regs, 0) == -1)

12
gdb/mipsnbsd-nat.c
View file

@ -40,7 +40,7 @@ getregs_supplies (int regno)
}
static void
mipsnbsd_fetch_inferior_registers (int regno)
mipsnbsd_fetch_inferior_registers (struct regcache *regcache, int regno)
{
if (regno == -1 || getregs_supplies (regno))
{
@ -50,7 +50,7 @@ mipsnbsd_fetch_inferior_registers (int regno)
(PTRACE_TYPE_ARG3) &regs, 0) == -1)
perror_with_name (_("Couldn't get registers"));
mipsnbsd_supply_reg (current_regcache, (char *) &regs, regno);
mipsnbsd_supply_reg (regcache, (char *) &regs, regno);
if (regno != -1)
return;
}
@ -63,12 +63,12 @@ mipsnbsd_fetch_inferior_registers (int regno)
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
perror_with_name (_("Couldn't get floating point status"));
mipsnbsd_supply_fpreg (current_regcache, (char *) &fpregs, regno);
mipsnbsd_supply_fpreg (regcache, (char *) &fpregs, regno);
}
}
static void
mipsnbsd_store_inferior_registers (int regno)
mipsnbsd_store_inferior_registers (struct regcache *regcache, int regno)
{
if (regno == -1 || getregs_supplies (regno))
{
@ -78,7 +78,7 @@ mipsnbsd_store_inferior_registers (int regno)
(PTRACE_TYPE_ARG3) &regs, 0) == -1)
perror_with_name (_("Couldn't get registers"));
mipsnbsd_fill_reg (current_regcache, (char *) &regs, regno);
mipsnbsd_fill_reg (regcache, (char *) &regs, regno);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &regs, 0) == -1)
@ -96,7 +96,7 @@ mipsnbsd_store_inferior_registers (int regno)
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
perror_with_name (_("Couldn't get floating point status"));
mipsnbsd_fill_fpreg (current_regcache, (char *) &fpregs, regno);
mipsnbsd_fill_fpreg (regcache, (char *) &fpregs, regno);
if (ptrace (PT_SETFPREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)

24
gdb/monitor.c
View file

@ -1129,7 +1129,7 @@ monitor_wait (ptid_t ptid, struct target_waitstatus *status)
errno value. */
static void
monitor_fetch_register (int regno)
monitor_fetch_register (struct regcache *regcache, int regno)
{
const char *name;
char *zerobuf;
@ -1149,7 +1149,7 @@ monitor_fetch_register (int regno)
if (!name || (*name == '\0'))
{
monitor_debug ("No register known for %d\n", regno);
regcache_raw_supply (current_regcache, regno, zerobuf);
regcache_raw_supply (regcache, regno, zerobuf);
return;
}
@ -1228,7 +1228,7 @@ monitor_fetch_register (int regno)
current_monitor->getreg.term_cmd) /* ack expected */
monitor_expect_prompt (NULL, 0); /* get response */
monitor_supply_register (current_regcache, regno, regbuf);
monitor_supply_register (regcache, regno, regbuf);
}
/* Sometimes, it takes several commands to dump the registers */
@ -1268,30 +1268,30 @@ monitor_dump_regs (struct regcache *regcache)
}
static void
monitor_fetch_registers (int regno)
monitor_fetch_registers (struct regcache *regcache, int regno)
{
monitor_debug ("MON fetchregs\n");
if (current_monitor->getreg.cmd)
{
if (regno >= 0)
{
monitor_fetch_register (regno);
monitor_fetch_register (regcache, regno);
return;
}
for (regno = 0; regno < NUM_REGS; regno++)
monitor_fetch_register (regno);
monitor_fetch_register (regcache, regno);
}
else
{
monitor_dump_regs (current_regcache);
monitor_dump_regs (regcache);
}
}
/* Store register REGNO, or all if REGNO == 0. Return errno value. */
static void
monitor_store_register (int regno)
monitor_store_register (struct regcache *regcache, int regno)
{
const char *name;
ULONGEST val;
@ -1307,7 +1307,7 @@ monitor_store_register (int regno)
return;
}
val = read_register (regno);
regcache_cooked_read_unsigned (regcache, regno, &val);
monitor_debug ("MON storeg %d %s\n", regno,
phex (val, register_size (current_gdbarch, regno)));
@ -1348,16 +1348,16 @@ monitor_store_register (int regno)
/* Store the remote registers. */
static void
monitor_store_registers (int regno)
monitor_store_registers (struct regcache *regcache, int regno)
{
if (regno >= 0)
{
monitor_store_register (regno);
monitor_store_register (regcache, regno);
return;
}
for (regno = 0; regno < NUM_REGS; regno++)
monitor_store_register (regno);
monitor_store_register (regcache, regno);
}
/* Get ready to modify the registers array. On machines which store

16
gdb/nto-procfs.c
View file

@ -67,7 +67,7 @@ static int procfs_xfer_memory (CORE_ADDR, char *, int, int,
struct mem_attrib *attrib,
struct target_ops *);
static void procfs_fetch_registers (int);
static void procfs_fetch_registers (struct regcache *, int);
static void notice_signals (void);
@ -714,7 +714,7 @@ procfs_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
general register set and floating point registers (if supported)
and update gdb's idea of their current values. */
static void
procfs_fetch_registers (int regno)
procfs_fetch_registers (struct regcache *regcache, int regno)
{
union
{
@ -727,13 +727,13 @@ procfs_fetch_registers (int regno)
procfs_set_thread (inferior_ptid);
if (devctl (ctl_fd, DCMD_PROC_GETGREG, &reg, sizeof (reg), &regsize) == EOK)
nto_supply_gregset (current_regcache, (char *) &reg.greg);
nto_supply_gregset (regcache, (char *) &reg.greg);
if (devctl (ctl_fd, DCMD_PROC_GETFPREG, &reg, sizeof (reg), &regsize)
== EOK)
nto_supply_fpregset (current_regcache, (char *) &reg.fpreg);
nto_supply_fpregset (regcache, (char *) &reg.fpreg);
if (devctl (ctl_fd, DCMD_PROC_GETALTREG, &reg, sizeof (reg), &regsize)
== EOK)
nto_supply_altregset (current_regcache, (char *) &reg.altreg);
nto_supply_altregset (regcache, (char *) &reg.altreg);
}
/* Copy LEN bytes to/from inferior's memory starting at MEMADDR
@ -1147,7 +1147,7 @@ get_regset (int regset, char *buf, int bufsize, int *regsize)
}
void
procfs_store_registers (int regno)
procfs_store_registers (struct regcache *regcache, int regno)
{
union
{
@ -1173,7 +1173,7 @@ procfs_store_registers (int regno)
if (dev_set == -1)
continue;
if (nto_regset_fill (current_regcache, regset, (char *) &reg) == -1)
if (nto_regset_fill (regcache, regset, (char *) &reg) == -1)
continue;
err = devctl (ctl_fd, dev_set, &reg, regsize, 0);
@ -1198,7 +1198,7 @@ procfs_store_registers (int regno)
if (len < 1)
return;
regcache_raw_collect (current_regcache, regno, (char *) &reg + off);
regcache_raw_collect (regcache, regno, (char *) &reg + off);
err = devctl (ctl_fd, dev_set, &reg, regsize, 0);
if (err != EOK)

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

@ -226,7 +226,7 @@ ppc_register_u_addr (int regno)
registers set mechanism, as opposed to the interface for all the
other registers, that stores/fetches each register individually. */
static void
fetch_altivec_register (int tid, int regno)
fetch_altivec_register (struct regcache *regcache, int tid, int regno)
{
int ret;
int offset = 0;
@ -252,7 +252,7 @@ fetch_altivec_register (int tid, int regno)
if (regno == (tdep->ppc_vrsave_regnum - 1))
offset = vrregsize - register_size (current_gdbarch, tdep->ppc_vrsave_regnum);
regcache_raw_supply (current_regcache, regno,
regcache_raw_supply (regcache, regno,
regs + (regno - tdep->ppc_vr0_regnum) * vrregsize + offset);
}
@ -291,7 +291,7 @@ get_spe_registers (int tid, struct gdb_evrregset_t *evrregset)
be the number of an upper half register, acc, spefscr, or -1 to
supply the values of all registers. */
static void
fetch_spe_register (int tid, int regno)
fetch_spe_register (struct regcache *regcache, int tid, int regno)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
struct gdb_evrregset_t evrregs;
@ -310,26 +310,26 @@ fetch_spe_register (int tid, int regno)
int i;
for (i = 0; i < ppc_num_gprs; i++)
regcache_raw_supply (current_regcache, tdep->ppc_ev0_upper_regnum + i,
regcache_raw_supply (regcache, tdep->ppc_ev0_upper_regnum + i,
&evrregs.evr[i]);
}
else if (tdep->ppc_ev0_upper_regnum <= regno
&& regno < tdep->ppc_ev0_upper_regnum + ppc_num_gprs)
regcache_raw_supply (current_regcache, regno,
regcache_raw_supply (regcache, regno,
&evrregs.evr[regno - tdep->ppc_ev0_upper_regnum]);
if (regno == -1
|| regno == tdep->ppc_acc_regnum)
regcache_raw_supply (current_regcache, tdep->ppc_acc_regnum, &evrregs.acc);
regcache_raw_supply (regcache, tdep->ppc_acc_regnum, &evrregs.acc);
if (regno == -1
|| regno == tdep->ppc_spefscr_regnum)
regcache_raw_supply (current_regcache, tdep->ppc_spefscr_regnum,
regcache_raw_supply (regcache, tdep->ppc_spefscr_regnum,
&evrregs.spefscr);
}
static void
fetch_register (int tid, int regno)
fetch_register (struct regcache *regcache, int tid, int regno)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
/* This isn't really an address. But ptrace thinks of it as one. */
@ -346,7 +346,7 @@ fetch_register (int tid, int regno)
register. */
if (have_ptrace_getvrregs)
{
fetch_altivec_register (tid, regno);
fetch_altivec_register (regcache, tid, regno);
return;
}
/* If we have discovered that there is no ptrace support for
@ -355,14 +355,14 @@ fetch_register (int tid, int regno)
}
else if (spe_register_p (regno))
{
fetch_spe_register (tid, regno);
fetch_spe_register (regcache, tid, regno);
return;
}
if (regaddr == -1)
{
memset (buf, '\0', register_size (current_gdbarch, regno)); /* Supply zeroes */
regcache_raw_supply (current_regcache, regno, buf);
regcache_raw_supply (regcache, regno, buf);
return;
}
@ -393,7 +393,7 @@ fetch_register (int tid, int regno)
{
/* Little-endian values are always found at the left end of the
bytes transferred. */
regcache_raw_supply (current_regcache, regno, buf);
regcache_raw_supply (regcache, regno, buf);
}
else if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
{
@ -401,7 +401,7 @@ fetch_register (int tid, int regno)
transferred. */
size_t padding = (bytes_transferred
- register_size (current_gdbarch, regno));
regcache_raw_supply (current_regcache, regno, buf + padding);
regcache_raw_supply (regcache, regno, buf + padding);
}
else
internal_error (__FILE__, __LINE__,
@ -410,7 +410,7 @@ fetch_register (int tid, int regno)
}
static void
supply_vrregset (gdb_vrregset_t *vrregsetp)
supply_vrregset (struct regcache *regcache, gdb_vrregset_t *vrregsetp)
{
int i;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
@ -425,16 +425,16 @@ supply_vrregset (gdb_vrregset_t *vrregsetp)
occupies a whole vector, while VRSAVE occupies a full 4 bytes
slot. */
if (i == (num_of_vrregs - 2))
regcache_raw_supply (current_regcache, tdep->ppc_vr0_regnum + i,
regcache_raw_supply (regcache, tdep->ppc_vr0_regnum + i,
*vrregsetp + i * vrregsize + offset);
else
regcache_raw_supply (current_regcache, tdep->ppc_vr0_regnum + i,
regcache_raw_supply (regcache, tdep->ppc_vr0_regnum + i,
*vrregsetp + i * vrregsize);
}
}
static void
fetch_altivec_registers (int tid)
fetch_altivec_registers (struct regcache *regcache, int tid)
{
int ret;
gdb_vrregset_t regs;
@ -449,47 +449,47 @@ fetch_altivec_registers (int tid)
}
perror_with_name (_("Unable to fetch AltiVec registers"));
}
supply_vrregset (&regs);
supply_vrregset (regcache, &regs);
}
static void
fetch_ppc_registers (int tid)
fetch_ppc_registers (struct regcache *regcache, int tid)
{
int i;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
for (i = 0; i < ppc_num_gprs; i++)
fetch_register (tid, tdep->ppc_gp0_regnum + i);
fetch_register (regcache, tid, tdep->ppc_gp0_regnum + i);
if (tdep->ppc_fp0_regnum >= 0)
for (i = 0; i < ppc_num_fprs; i++)
fetch_register (tid, tdep->ppc_fp0_regnum + i);
fetch_register (tid, PC_REGNUM);
fetch_register (regcache, tid, tdep->ppc_fp0_regnum + i);
fetch_register (regcache, tid, PC_REGNUM);
if (tdep->ppc_ps_regnum != -1)
fetch_register (tid, tdep->ppc_ps_regnum);
fetch_register (regcache, tid, tdep->ppc_ps_regnum);
if (tdep->ppc_cr_regnum != -1)
fetch_register (tid, tdep->ppc_cr_regnum);
fetch_register (regcache, tid, tdep->ppc_cr_regnum);
if (tdep->ppc_lr_regnum != -1)
fetch_register (tid, tdep->ppc_lr_regnum);
fetch_register (regcache, tid, tdep->ppc_lr_regnum);
if (tdep->ppc_ctr_regnum != -1)
fetch_register (tid, tdep->ppc_ctr_regnum);
fetch_register (regcache, tid, tdep->ppc_ctr_regnum);
if (tdep->ppc_xer_regnum != -1)
fetch_register (tid, tdep->ppc_xer_regnum);
fetch_register (regcache, tid, tdep->ppc_xer_regnum);
if (tdep->ppc_mq_regnum != -1)
fetch_register (tid, tdep->ppc_mq_regnum);
fetch_register (regcache, tid, tdep->ppc_mq_regnum);
if (tdep->ppc_fpscr_regnum != -1)
fetch_register (tid, tdep->ppc_fpscr_regnum);
fetch_register (regcache, tid, tdep->ppc_fpscr_regnum);
if (have_ptrace_getvrregs)
if (tdep->ppc_vr0_regnum != -1 && tdep->ppc_vrsave_regnum != -1)
fetch_altivec_registers (tid);
fetch_altivec_registers (regcache, tid);
if (tdep->ppc_ev0_upper_regnum >= 0)
fetch_spe_register (tid, -1);
fetch_spe_register (regcache, tid, -1);
}
/* Fetch registers from the child process. Fetch all registers if
regno == -1, otherwise fetch all general registers or all floating
point registers depending upon the value of regno. */
static void
ppc_linux_fetch_inferior_registers (int regno)
ppc_linux_fetch_inferior_registers (struct regcache *regcache, int regno)
{
/* Overload thread id onto process id */
int tid = TIDGET (inferior_ptid);
@ -499,14 +499,14 @@ ppc_linux_fetch_inferior_registers (int regno)
tid = PIDGET (inferior_ptid);
if (regno == -1)
fetch_ppc_registers (tid);
fetch_ppc_registers (regcache, tid);
else
fetch_register (tid, regno);
fetch_register (regcache, tid, regno);
}
/* Store one register. */
static void
store_altivec_register (int tid, int regno)
store_altivec_register (const struct regcache *regcache, int tid, int regno)
{
int ret;
int offset = 0;
@ -530,7 +530,7 @@ store_altivec_register (int tid, int regno)
if (regno == (tdep->ppc_vrsave_regnum - 1))
offset = vrregsize - register_size (current_gdbarch, tdep->ppc_vrsave_regnum);
regcache_raw_collect (current_regcache, regno,
regcache_raw_collect (regcache, regno,
regs + (regno - tdep->ppc_vr0_regnum) * vrregsize + offset);
ret = ptrace (PTRACE_SETVRREGS, tid, 0, &regs);
@ -571,7 +571,7 @@ set_spe_registers (int tid, struct gdb_evrregset_t *evrregset)
If REGNO is -1, write the values of all the SPE-specific
registers. */
static void
store_spe_register (int tid, int regno)
store_spe_register (const struct regcache *regcache, int tid, int regno)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
struct gdb_evrregset_t evrregs;
@ -599,24 +599,24 @@ store_spe_register (int tid, int regno)
int i;
for (i = 0; i < ppc_num_gprs; i++)
regcache_raw_collect (current_regcache,
regcache_raw_collect (regcache,
tdep->ppc_ev0_upper_regnum + i,
&evrregs.evr[i]);
}
else if (tdep->ppc_ev0_upper_regnum <= regno
&& regno < tdep->ppc_ev0_upper_regnum + ppc_num_gprs)
regcache_raw_collect (current_regcache, regno,
regcache_raw_collect (regcache, regno,
&evrregs.evr[regno - tdep->ppc_ev0_upper_regnum]);
if (regno == -1
|| regno == tdep->ppc_acc_regnum)
regcache_raw_collect (current_regcache,
regcache_raw_collect (regcache,
tdep->ppc_acc_regnum,
&evrregs.acc);
if (regno == -1
|| regno == tdep->ppc_spefscr_regnum)
regcache_raw_collect (current_regcache,
regcache_raw_collect (regcache,
tdep->ppc_spefscr_regnum,
&evrregs.spefscr);
@ -625,7 +625,7 @@ store_spe_register (int tid, int regno)
}
static void
store_register (int tid, int regno)
store_register (const struct regcache *regcache, int tid, int regno)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
/* This isn't really an address. But ptrace thinks of it as one. */
@ -636,12 +636,12 @@ store_register (int tid, int regno)
if (altivec_register_p (regno))
{
store_altivec_register (tid, regno);
store_altivec_register (regcache, tid, regno);
return;
}
else if (spe_register_p (regno))
{
store_spe_register (tid, regno);
store_spe_register (regcache, tid, regno);
return;
}
@ -657,14 +657,14 @@ store_register (int tid, int regno)
if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
{
/* Little-endian values always sit at the left end of the buffer. */
regcache_raw_collect (current_regcache, regno, buf);
regcache_raw_collect (regcache, regno, buf);
}
else if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
{
/* Big-endian values sit at the right end of the buffer. */
size_t padding = (bytes_to_transfer
- register_size (current_gdbarch, regno));
regcache_raw_collect (current_regcache, regno, buf + padding);
regcache_raw_collect (regcache, regno, buf + padding);
}
for (i = 0; i < bytes_to_transfer; i += sizeof (long))
@ -692,7 +692,7 @@ store_register (int tid, int regno)
}
static void
fill_vrregset (gdb_vrregset_t *vrregsetp)
fill_vrregset (const struct regcache *regcache, gdb_vrregset_t *vrregsetp)
{
int i;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
@ -705,16 +705,16 @@ 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_raw_collect (current_regcache, tdep->ppc_vr0_regnum + i,
regcache_raw_collect (regcache, tdep->ppc_vr0_regnum + i,
*vrregsetp + i * vrregsize + offset);
else
regcache_raw_collect (current_regcache, tdep->ppc_vr0_regnum + i,
regcache_raw_collect (regcache, tdep->ppc_vr0_regnum + i,
*vrregsetp + i * vrregsize);
}
}
static void
store_altivec_registers (int tid)
store_altivec_registers (const struct regcache *regcache, int tid)
{
int ret;
gdb_vrregset_t regs;
@ -730,43 +730,43 @@ store_altivec_registers (int tid)
perror_with_name (_("Couldn't get AltiVec registers"));
}
fill_vrregset (&regs);
fill_vrregset (regcache, &regs);
if (ptrace (PTRACE_SETVRREGS, tid, 0, &regs) < 0)
perror_with_name (_("Couldn't write AltiVec registers"));
}
static void
store_ppc_registers (int tid)
store_ppc_registers (const struct regcache *regcache, int tid)
{
int i;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
for (i = 0; i < ppc_num_gprs; i++)
store_register (tid, tdep->ppc_gp0_regnum + i);
store_register (regcache, tid, tdep->ppc_gp0_regnum + i);
if (tdep->ppc_fp0_regnum >= 0)
for (i = 0; i < ppc_num_fprs; i++)
store_register (tid, tdep->ppc_fp0_regnum + i);
store_register (tid, PC_REGNUM);
store_register (regcache, tid, tdep->ppc_fp0_regnum + i);
store_register (regcache, tid, PC_REGNUM);
if (tdep->ppc_ps_regnum != -1)
store_register (tid, tdep->ppc_ps_regnum);
store_register (regcache, tid, tdep->ppc_ps_regnum);
if (tdep->ppc_cr_regnum != -1)
store_register (tid, tdep->ppc_cr_regnum);
store_register (regcache, tid, tdep->ppc_cr_regnum);
if (tdep->ppc_lr_regnum != -1)
store_register (tid, tdep->ppc_lr_regnum);
store_register (regcache, tid, tdep->ppc_lr_regnum);
if (tdep->ppc_ctr_regnum != -1)
store_register (tid, tdep->ppc_ctr_regnum);
store_register (regcache, tid, tdep->ppc_ctr_regnum);
if (tdep->ppc_xer_regnum != -1)
store_register (tid, tdep->ppc_xer_regnum);
store_register (regcache, tid, tdep->ppc_xer_regnum);
if (tdep->ppc_mq_regnum != -1)
store_register (tid, tdep->ppc_mq_regnum);
store_register (regcache, tid, tdep->ppc_mq_regnum);
if (tdep->ppc_fpscr_regnum != -1)
store_register (tid, tdep->ppc_fpscr_regnum);
store_register (regcache, tid, tdep->ppc_fpscr_regnum);
if (have_ptrace_getvrregs)
if (tdep->ppc_vr0_regnum != -1 && tdep->ppc_vrsave_regnum != -1)
store_altivec_registers (tid);
store_altivec_registers (regcache, tid);
if (tdep->ppc_ev0_upper_regnum >= 0)
store_spe_register (tid, -1);
store_spe_register (regcache, tid, -1);
}
static int
@ -888,7 +888,7 @@ ppc_linux_stopped_by_watchpoint (void)
}
static void
ppc_linux_store_inferior_registers (int regno)
ppc_linux_store_inferior_registers (struct regcache *regcache, int regno)
{
/* Overload thread id onto process id */
int tid = TIDGET (inferior_ptid);
@ -898,9 +898,9 @@ ppc_linux_store_inferior_registers (int regno)
tid = PIDGET (inferior_ptid);
if (regno >= 0)
store_register (tid, regno);
store_register (regcache, tid, regno);
else
store_ppc_registers (tid);
store_ppc_registers (regcache, tid);
}
void
@ -957,7 +957,7 @@ fill_gregset (const struct regcache *regcache,
regcache_raw_collect (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);
right_fill_reg (regcache, tdep->ppc_ctr_regnum, regp + PT_CTR);
#ifdef PT_MQ
if (((regno == -1) || regno == tdep->ppc_mq_regnum)
&& (tdep->ppc_mq_regnum != -1))
@ -995,7 +995,7 @@ fill_fpregset (const struct regcache *regcache,
fpp + 8 * regi);
}
if (regno == -1 || regno == tdep->ppc_fpscr_regnum)
right_fill_reg (tdep->ppc_fpscr_regnum, (fpp + 8 * 32));
right_fill_reg (regcache, tdep->ppc_fpscr_regnum, (fpp + 8 * 32));
}
}

12
gdb/ppcnbsd-nat.c
View file

@ -80,7 +80,7 @@ getfpregs_supplies (int regnum)
}
static void
ppcnbsd_fetch_inferior_registers (int regnum)
ppcnbsd_fetch_inferior_registers (struct regcache *regcache, int regnum)
{
if (regnum == -1 || getregs_supplies (regnum))
{
@ -90,7 +90,7 @@ ppcnbsd_fetch_inferior_registers (int regnum)
(PTRACE_TYPE_ARG3) &regs, 0) == -1)
perror_with_name (_("Couldn't get registers"));
ppc_supply_gregset (&ppcnbsd_gregset, current_regcache,
ppc_supply_gregset (&ppcnbsd_gregset, regcache,
regnum, &regs, sizeof regs);
}
@ -102,13 +102,13 @@ ppcnbsd_fetch_inferior_registers (int regnum)
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
perror_with_name (_("Couldn't get FP registers"));
ppc_supply_fpregset (&ppcnbsd_fpregset, current_regcache,
ppc_supply_fpregset (&ppcnbsd_fpregset, regcache,
regnum, &fpregs, sizeof fpregs);
}
}
static void
ppcnbsd_store_inferior_registers (int regnum)
ppcnbsd_store_inferior_registers (struct regcache *regcache, int regnum)
{
if (regnum == -1 || getregs_supplies (regnum))
{
@ -118,7 +118,7 @@ ppcnbsd_store_inferior_registers (int regnum)
(PTRACE_TYPE_ARG3) &regs, 0) == -1)
perror_with_name (_("Couldn't get registers"));
ppc_collect_gregset (&ppcnbsd_gregset, current_regcache,
ppc_collect_gregset (&ppcnbsd_gregset, regcache,
regnum, &regs, sizeof regs);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
@ -134,7 +134,7 @@ ppcnbsd_store_inferior_registers (int regnum)
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
perror_with_name (_("Couldn't get FP registers"));
ppc_collect_fpregset (&ppcnbsd_fpregset, current_regcache,
ppc_collect_fpregset (&ppcnbsd_fpregset, regcache,
regnum, &fpregs, sizeof fpregs);
if (ptrace (PT_SETFPREGS, PIDGET (inferior_ptid),

16
gdb/ppcobsd-nat.c
View file

@ -74,7 +74,7 @@ getfpregs_supplies (int regnum)
for all registers. */
static void
ppcobsd_fetch_registers (int regnum)
ppcobsd_fetch_registers (struct regcache *regcache, int regnum)
{
struct reg regs;
@ -82,10 +82,10 @@ ppcobsd_fetch_registers (int regnum)
(PTRACE_TYPE_ARG3) &regs, 0) == -1)
perror_with_name (_("Couldn't get registers"));
ppc_supply_gregset (&ppcobsd_gregset, current_regcache, -1,
ppc_supply_gregset (&ppcobsd_gregset, regcache, -1,
&regs, sizeof regs);
#ifndef PT_GETFPREGS
ppc_supply_fpregset (&ppcobsd_gregset, current_regcache, -1,
ppc_supply_fpregset (&ppcobsd_gregset, regcache, -1,
&regs, sizeof regs);
#endif
@ -98,7 +98,7 @@ ppcobsd_fetch_registers (int regnum)
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
perror_with_name (_("Couldn't get floating point status"));
ppc_supply_fpregset (&ppcobsd_fpregset, current_regcache, -1,
ppc_supply_fpregset (&ppcobsd_fpregset, regcache, -1,
&fpregs, sizeof fpregs);
}
#endif
@ -108,7 +108,7 @@ ppcobsd_fetch_registers (int regnum)
this for all registers. */
static void
ppcobsd_store_registers (int regnum)
ppcobsd_store_registers (struct regcache *regcache, int regnum)
{
struct reg regs;
@ -116,10 +116,10 @@ ppcobsd_store_registers (int regnum)
(PTRACE_TYPE_ARG3) &regs, 0) == -1)
perror_with_name (_("Couldn't get registers"));
ppc_collect_gregset (&ppcobsd_gregset, current_regcache,
ppc_collect_gregset (&ppcobsd_gregset, regcache,
regnum, &regs, sizeof regs);
#ifndef PT_GETFPREGS
ppc_collect_fpregset (&ppcobsd_gregset, current_regcache,
ppc_collect_fpregset (&ppcobsd_gregset, regcache,
regnum, &regs, sizeof regs);
#endif
@ -136,7 +136,7 @@ ppcobsd_store_registers (int regnum)
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
perror_with_name (_("Couldn't get floating point status"));
ppc_collect_fpregset (&ppcobsd_fpregset, current_regcache,
ppc_collect_fpregset (&ppcobsd_fpregset, regcache,
regnum, &fpregs, sizeof fpregs);
if (ptrace (PT_SETFPREGS, PIDGET (inferior_ptid),

8
gdb/proc-service.c
View file

@ -234,7 +234,7 @@ ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, prgregset_t gregset)
inferior_ptid = BUILD_LWP (lwpid, ph->pid);
target_fetch_registers (-1);
target_fetch_registers (current_regcache, -1);
fill_gregset (current_regcache, (gdb_gregset_t *) gregset, -1);
do_cleanups (old_chain);
@ -252,7 +252,7 @@ ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, const prgregset_t gregset)
inferior_ptid = BUILD_LWP (lwpid, ph->pid);
supply_gregset (current_regcache, (const gdb_gregset_t *) gregset);
target_store_registers (-1);
target_store_registers (current_regcache, -1);
do_cleanups (old_chain);
return PS_OK;
@ -269,7 +269,7 @@ ps_lgetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
inferior_ptid = BUILD_LWP (lwpid, ph->pid);
target_fetch_registers (-1);
target_fetch_registers (current_regcache, -1);
fill_fpregset (current_regcache, (gdb_fpregset_t *) fpregset, -1);
do_cleanups (old_chain);
@ -288,7 +288,7 @@ ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
inferior_ptid = BUILD_LWP (lwpid, ph->pid);
supply_fpregset (current_regcache, (const gdb_fpregset_t *) fpregset);
target_store_registers (-1);
target_store_registers (current_regcache, -1);
do_cleanups (old_chain);
return PS_OK;

16
gdb/procfs.c
View file

@ -120,8 +120,8 @@ static void procfs_resume (ptid_t, int, enum target_signal);
static int procfs_can_run (void);
static void procfs_stop (void);
static void procfs_files_info (struct target_ops *);
static void procfs_fetch_registers (int);
static void procfs_store_registers (int);
static void procfs_fetch_registers (struct regcache *, int);
static void procfs_store_registers (struct regcache *, int);
static void procfs_notice_signals (ptid_t);
static void procfs_prepare_to_store (void);
static void procfs_kill_inferior (void);
@ -3682,7 +3682,7 @@ do_detach (int signo)
when the process is resumed. */
static void
procfs_fetch_registers (int regnum)
procfs_fetch_registers (struct regcache *regcache, int regnum)
{
gdb_gregset_t *gregs;
procinfo *pi;
@ -3706,7 +3706,7 @@ procfs_fetch_registers (int regnum)
if (gregs == NULL)
proc_error (pi, "fetch_registers, get_gregs", __LINE__);
supply_gregset (current_regcache, (const gdb_gregset_t *) gregs);
supply_gregset (regcache, (const gdb_gregset_t *) gregs);
if (FP0_REGNUM >= 0) /* Do we have an FPU? */
{
@ -3721,7 +3721,7 @@ procfs_fetch_registers (int regnum)
if (fpregs == NULL)
proc_error (pi, "fetch_registers, get_fpregs", __LINE__);
supply_fpregset (current_regcache, (const gdb_fpregset_t *) fpregs);
supply_fpregset (regcache, (const gdb_fpregset_t *) fpregs);
}
}
@ -3750,7 +3750,7 @@ procfs_prepare_to_store (void)
writing one register might affect the value of others, etc. */
static void
procfs_store_registers (int regnum)
procfs_store_registers (struct regcache *regcache, int regnum)
{
gdb_gregset_t *gregs;
procinfo *pi;
@ -3774,7 +3774,7 @@ procfs_store_registers (int regnum)
if (gregs == NULL)
proc_error (pi, "store_registers, get_gregs", __LINE__);
fill_gregset (current_regcache, gregs, regnum);
fill_gregset (regcache, gregs, regnum);
if (!proc_set_gregs (pi))
proc_error (pi, "store_registers, set_gregs", __LINE__);
@ -3791,7 +3791,7 @@ procfs_store_registers (int regnum)
if (fpregs == NULL)
proc_error (pi, "store_registers, get_fpregs", __LINE__);
fill_fpregset (current_regcache, fpregs, regnum);
fill_fpregset (regcache, fpregs, regnum);
if (!proc_set_fpregs (pi))
proc_error (pi, "store_registers, set_fpregs", __LINE__);
}

6
gdb/regcache.c
View file

@ -508,8 +508,8 @@ regcache_raw_read (struct regcache *regcache, int regnum, gdb_byte *buf)
registers_changed ();
registers_ptid = inferior_ptid;
}
if (!register_cached (regnum))
target_fetch_registers (regnum);
if (!regcache_valid_p (regcache, regnum))
target_fetch_registers (regcache, regnum);
#if 0
/* FIXME: cagney/2004-08-07: At present a number of targets
forget (or didn't know that they needed) to set this leading to
@ -673,7 +673,7 @@ regcache_raw_write (struct regcache *regcache, int regnum,
memcpy (register_buffer (regcache, regnum), buf,
regcache->descr->sizeof_register[regnum]);
regcache->register_valid_p[regnum] = 1;
target_store_registers (regnum);
target_store_registers (regcache, regnum);
}
void

24
gdb/remote-m32r-sdi.c
View file

@ -903,26 +903,26 @@ get_reg_id (int regno)
/* Read the remote registers into the block REGS. */
static void m32r_fetch_register (int);
static void m32r_fetch_register (struct regcache *, int);
static void
m32r_fetch_registers (void)
m32r_fetch_registers (struct regcache *regcache)
{
int regno;
for (regno = 0; regno < NUM_REGS; regno++)
m32r_fetch_register (regno);
m32r_fetch_register (regcache, regno);
}
/* Fetch register REGNO, or all registers if REGNO is -1.
Returns errno value. */
static void
m32r_fetch_register (int regno)
m32r_fetch_register (struct regcache *regcache, int regno)
{
unsigned long val, val2, regid;
if (regno == -1)
m32r_fetch_registers ();
m32r_fetch_registers (regcache);
else
{
char buffer[MAX_REGISTER_SIZE];
@ -945,22 +945,22 @@ m32r_fetch_register (int regno)
/* We got the number the register holds, but gdb expects to see a
value in the target byte ordering. */
store_unsigned_integer (buffer, 4, val);
regcache_raw_supply (current_regcache, regno, buffer);
regcache_raw_supply (regcache, regno, buffer);
}
return;
}
/* Store the remote registers from the contents of the block REGS. */
static void m32r_store_register (int);
static void m32r_store_register (struct regcache *, int);
static void
m32r_store_registers (void)
m32r_store_registers (struct regcache *regcache)
{
int regno;
for (regno = 0; regno < NUM_REGS; regno++)
m32r_store_register (regno);
m32r_store_register (regcache, regno);
registers_changed ();
}
@ -968,16 +968,16 @@ m32r_store_registers (void)
/* Store register REGNO, or all if REGNO == 0.
Return errno value. */
static void
m32r_store_register (int regno)
m32r_store_register (struct regcache *regcache, int regno)
{
int regid;
ULONGEST regval, tmp;
if (regno == -1)
m32r_store_registers ();
m32r_store_registers (regcache);
else
{
regcache_cooked_read_unsigned (current_regcache, regno, &regval);
regcache_cooked_read_unsigned (regcache, regno, &regval);
regid = get_reg_id (regno);
if (regid == SDI_REG_PSW)

19
gdb/remote-mips.c
View file

@ -96,11 +96,11 @@ static ptid_t mips_wait (ptid_t ptid,
static int mips_map_regno (int regno);
static void mips_fetch_registers (int regno);
static void mips_fetch_registers (struct regcache *regcache, int regno);
static void mips_prepare_to_store (void);
static void mips_store_registers (int regno);
static void mips_store_registers (struct regcache *regcache, int regno);
static unsigned int mips_fetch_word (CORE_ADDR addr);
@ -1892,7 +1892,7 @@ mips_map_regno (int regno)
/* Fetch the remote registers. */
static void
mips_fetch_registers (int regno)
mips_fetch_registers (struct regcache *regcache, int regno)
{
unsigned LONGEST val;
int err;
@ -1900,7 +1900,7 @@ mips_fetch_registers (int regno)
if (regno == -1)
{
for (regno = 0; regno < NUM_REGS; regno++)
mips_fetch_registers (regno);
mips_fetch_registers (regcache, regno);
return;
}
@ -1938,7 +1938,7 @@ mips_fetch_registers (int regno)
/* We got the number the register holds, but gdb expects to see a
value in the target byte ordering. */
store_unsigned_integer (buf, register_size (current_gdbarch, regno), val);
regcache_raw_supply (current_regcache, regno, buf);
regcache_raw_supply (regcache, regno, buf);
}
}
@ -1953,19 +1953,20 @@ mips_prepare_to_store (void)
/* Store remote register(s). */
static void
mips_store_registers (int regno)
mips_store_registers (struct regcache *regcache, int regno)
{
ULONGEST val;
int err;
if (regno == -1)
{
for (regno = 0; regno < NUM_REGS; regno++)
mips_store_registers (regno);
mips_store_registers (regcache, regno);
return;
}
mips_request ('R', mips_map_regno (regno),
read_register (regno),
regcache_cooked_read_unsigned (regcache, regno, &val);
mips_request ('R', mips_map_regno (regno), val,
&err, mips_receive_wait, NULL);
if (err)
mips_error ("Can't write register %d: %s", regno, safe_strerror (errno));

19
gdb/remote-sim.c
View file

@ -73,9 +73,9 @@ static void gdb_os_evprintf_filtered (host_callback *, const char *, va_list);
static void gdb_os_error (host_callback *, const char *, ...);
static void gdbsim_fetch_register (int regno);
static void gdbsim_fetch_register (struct regcache *regcache, int regno);
static void gdbsim_store_register (int regno);
static void gdbsim_store_register (struct regcache *regcache, int regno);
static void gdbsim_kill (void);
@ -279,12 +279,12 @@ one2one_register_sim_regno (int regnum)
}
static void
gdbsim_fetch_register (int regno)
gdbsim_fetch_register (struct regcache *regcache, int regno)
{
if (regno == -1)
{
for (regno = 0; regno < NUM_REGS; regno++)
gdbsim_fetch_register (regno);
gdbsim_fetch_register (regcache, regno);
return;
}
@ -299,10 +299,11 @@ gdbsim_fetch_register (int regno)
char buf[MAX_REGISTER_SIZE];
int nr_bytes;
memset (buf, 0, MAX_REGISTER_SIZE);
regcache_raw_supply (current_regcache, regno, buf);
regcache_raw_supply (regcache, regno, buf);
set_register_cached (regno, -1);
break;
}
default:
{
static int warn_user = 1;
@ -327,7 +328,7 @@ gdbsim_fetch_register (int regno)
which registers are fetchable. */
/* Else if (nr_bytes < 0): an old simulator, that doesn't
think to return the register size. Just assume all is ok. */
regcache_raw_supply (current_regcache, regno, buf);
regcache_raw_supply (regcache, regno, buf);
if (remote_debug)
{
printf_filtered ("gdbsim_fetch_register: %d", regno);
@ -341,19 +342,19 @@ gdbsim_fetch_register (int regno)
static void
gdbsim_store_register (int regno)
gdbsim_store_register (struct regcache *regcache, int regno)
{
if (regno == -1)
{
for (regno = 0; regno < NUM_REGS; regno++)
gdbsim_store_register (regno);
gdbsim_store_register (regcache, regno);
return;
}
else if (REGISTER_SIM_REGNO (regno) >= 0)
{
char tmp[MAX_REGISTER_SIZE];
int nr_bytes;
regcache_cooked_read (current_regcache, regno, tmp);
regcache_cooked_read (regcache, regno, tmp);
nr_bytes = sim_store_register (gdbsim_desc,
REGISTER_SIM_REGNO (regno),
tmp, register_size (current_gdbarch, regno));

52
gdb/remote.c
View file

@ -91,7 +91,7 @@ static void remote_files_info (struct target_ops *ignore);
static void remote_prepare_to_store (void);
static void remote_fetch_registers (int regno);
static void remote_fetch_registers (struct regcache *regcache, int regno);
static void remote_resume (ptid_t ptid, int step,
enum target_signal siggnal);
@ -108,7 +108,7 @@ static void remote_open_1 (char *, int, struct target_ops *, int extended_p,
static void remote_close (int quitting);
static void remote_store_registers (int regno);
static void remote_store_registers (struct regcache *regcache, int regno);
static void remote_mourn (void);
static void remote_async_mourn (void);
@ -3486,7 +3486,7 @@ got_status:
/* Fetch a single register using a 'p' packet. */
static int
fetch_register_using_p (struct packet_reg *reg)
fetch_register_using_p (struct regcache *regcache, struct packet_reg *reg)
{
struct remote_state *rs = get_remote_state ();
char *buf, *p;
@ -3521,7 +3521,7 @@ fetch_register_using_p (struct packet_reg *reg)
/* If this register is unfetchable, tell the regcache. */
if (buf[0] == 'x')
{
regcache_raw_supply (current_regcache, reg->regnum, NULL);
regcache_raw_supply (regcache, reg->regnum, NULL);
set_register_cached (reg->regnum, -1);
return 1;
}
@ -3537,7 +3537,7 @@ fetch_register_using_p (struct packet_reg *reg)
regp[i++] = fromhex (p[0]) * 16 + fromhex (p[1]);
p += 2;
}
regcache_raw_supply (current_regcache, reg->regnum, regp);
regcache_raw_supply (regcache, reg->regnum, regp);
return 1;
}
@ -3578,7 +3578,7 @@ send_g_packet (void)
}
static void
process_g_packet (void)
process_g_packet (struct regcache *regcache)
{
struct remote_state *rs = get_remote_state ();
struct remote_arch_state *rsa = get_remote_arch_state ();
@ -3660,11 +3660,11 @@ process_g_packet (void)
gdb_assert (r->offset * 2 < strlen (rs->buf));
/* The register isn't available, mark it as such (at
the same time setting the value to zero). */
regcache_raw_supply (current_regcache, r->regnum, NULL);
regcache_raw_supply (regcache, r->regnum, NULL);
set_register_cached (i, -1);
}
else
regcache_raw_supply (current_regcache, r->regnum,
regcache_raw_supply (regcache, r->regnum,
regs + r->offset);
}
}
@ -3672,14 +3672,14 @@ process_g_packet (void)
}
static void
fetch_registers_using_g (void)
fetch_registers_using_g (struct regcache *regcache)
{
send_g_packet ();
process_g_packet ();
process_g_packet (regcache);
}
static void
remote_fetch_registers (int regnum)
remote_fetch_registers (struct regcache *regcache, int regnum)
{
struct remote_state *rs = get_remote_state ();
struct remote_arch_state *rsa = get_remote_arch_state ();
@ -3698,29 +3698,29 @@ remote_fetch_registers (int regnum)
contents, so fall back to 'p'. */
if (reg->in_g_packet)
{
fetch_registers_using_g ();
fetch_registers_using_g (regcache);
if (reg->in_g_packet)
return;
}
if (fetch_register_using_p (reg))
if (fetch_register_using_p (regcache, reg))
return;
/* This register is not available. */
regcache_raw_supply (current_regcache, reg->regnum, NULL);
regcache_raw_supply (regcache, reg->regnum, NULL);
set_register_cached (reg->regnum, -1);
return;
}
fetch_registers_using_g ();
fetch_registers_using_g (regcache);
for (i = 0; i < NUM_REGS; i++)
if (!rsa->regs[i].in_g_packet)
if (!fetch_register_using_p (&rsa->regs[i]))
if (!fetch_register_using_p (regcache, &rsa->regs[i]))
{
/* This register is not available. */
regcache_raw_supply (current_regcache, i, NULL);
regcache_raw_supply (regcache, i, NULL);
set_register_cached (i, -1);
}
}
@ -3755,7 +3755,7 @@ remote_prepare_to_store (void)
packet was not recognized. */
static int
store_register_using_P (struct packet_reg *reg)
store_register_using_P (const struct regcache *regcache, struct packet_reg *reg)
{
struct remote_state *rs = get_remote_state ();
struct remote_arch_state *rsa = get_remote_arch_state ();
@ -3772,7 +3772,7 @@ store_register_using_P (struct packet_reg *reg)
xsnprintf (buf, get_remote_packet_size (), "P%s=", phex_nz (reg->pnum, 0));
p = buf + strlen (buf);
regcache_raw_collect (current_regcache, reg->regnum, regp);
regcache_raw_collect (regcache, reg->regnum, regp);
bin2hex (regp, p, register_size (current_gdbarch, reg->regnum));
remote_send (&rs->buf, &rs->buf_size);
@ -3794,7 +3794,7 @@ store_register_using_P (struct packet_reg *reg)
contents of the register cache buffer. FIXME: ignores errors. */
static void
store_registers_using_G (void)
store_registers_using_G (const struct regcache *regcache)
{
struct remote_state *rs = get_remote_state ();
struct remote_arch_state *rsa = get_remote_arch_state ();
@ -3811,7 +3811,7 @@ store_registers_using_G (void)
{
struct packet_reg *r = &rsa->regs[i];
if (r->in_g_packet)
regcache_raw_collect (current_regcache, r->regnum, regs + r->offset);
regcache_raw_collect (regcache, r->regnum, regs + r->offset);
}
}
@ -3829,7 +3829,7 @@ store_registers_using_G (void)
of the register cache buffer. FIXME: ignores errors. */
static void
remote_store_registers (int regnum)
remote_store_registers (struct regcache *regcache, int regnum)
{
struct remote_state *rs = get_remote_state ();
struct remote_arch_state *rsa = get_remote_arch_state ();
@ -3846,7 +3846,7 @@ remote_store_registers (int regnum)
possible; we often change only a small number of registers.
Sometimes we change a larger number; we'd need help from a
higher layer to know to use 'G'. */
if (store_register_using_P (reg))
if (store_register_using_P (regcache, reg))
return;
/* For now, don't complain if we have no way to write the
@ -3856,15 +3856,15 @@ remote_store_registers (int regnum)
if (!reg->in_g_packet)
return;
store_registers_using_G ();
store_registers_using_G (regcache);
return;
}
store_registers_using_G ();
store_registers_using_G (regcache);
for (i = 0; i < NUM_REGS; i++)
if (!rsa->regs[i].in_g_packet)
if (!store_register_using_P (&rsa->regs[i]))
if (!store_register_using_P (regcache, &rsa->regs[i]))
/* See above for why we do not issue an error here. */
continue;
}

56
gdb/rs6000-nat.c
View file

@ -210,7 +210,7 @@ rs6000_ptrace64 (int req, int id, long long addr, int data, void *buf)
/* Fetch register REGNO from the inferior. */
static void
fetch_register (int regno)
fetch_register (struct regcache *regcache, int regno)
{
int addr[MAX_REGISTER_SIZE];
int nr, isfloat;
@ -253,7 +253,7 @@ fetch_register (int regno)
}
if (!errno)
regcache_raw_supply (current_regcache, regno, (char *) addr);
regcache_raw_supply (regcache, regno, (char *) addr);
else
{
#if 0
@ -267,13 +267,13 @@ fetch_register (int regno)
/* Store register REGNO back into the inferior. */
static void
store_register (int regno)
store_register (const struct regcache *regcache, int regno)
{
int addr[MAX_REGISTER_SIZE];
int nr, isfloat;
/* Fetch the register's value from the register cache. */
regcache_raw_collect (current_regcache, regno, addr);
regcache_raw_collect (regcache, regno, addr);
/* -1 can be a successful return value, so infer errors from errno. */
errno = 0;
@ -333,10 +333,10 @@ store_register (int regno)
REGNO otherwise. */
static void
rs6000_fetch_inferior_registers (int regno)
rs6000_fetch_inferior_registers (struct regcache *regcache, int regno)
{
if (regno != -1)
fetch_register (regno);
fetch_register (regcache, regno);
else
{
@ -347,25 +347,25 @@ rs6000_fetch_inferior_registers (int regno)
regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
regno++)
{
fetch_register (regno);
fetch_register (regcache, regno);
}
/* Read general purpose floating point registers. */
if (tdep->ppc_fp0_regnum >= 0)
for (regno = 0; regno < ppc_num_fprs; regno++)
fetch_register (tdep->ppc_fp0_regnum + regno);
fetch_register (regcache, tdep->ppc_fp0_regnum + regno);
/* Read special registers. */
fetch_register (PC_REGNUM);
fetch_register (tdep->ppc_ps_regnum);
fetch_register (tdep->ppc_cr_regnum);
fetch_register (tdep->ppc_lr_regnum);
fetch_register (tdep->ppc_ctr_regnum);
fetch_register (tdep->ppc_xer_regnum);
fetch_register (regcache, PC_REGNUM);
fetch_register (regcache, tdep->ppc_ps_regnum);
fetch_register (regcache, tdep->ppc_cr_regnum);
fetch_register (regcache, tdep->ppc_lr_regnum);
fetch_register (regcache, tdep->ppc_ctr_regnum);
fetch_register (regcache, tdep->ppc_xer_regnum);
if (tdep->ppc_fpscr_regnum >= 0)
fetch_register (tdep->ppc_fpscr_regnum);
fetch_register (regcache, tdep->ppc_fpscr_regnum);
if (tdep->ppc_mq_regnum >= 0)
fetch_register (tdep->ppc_mq_regnum);
fetch_register (regcache, tdep->ppc_mq_regnum);
}
}
@ -374,10 +374,10 @@ rs6000_fetch_inferior_registers (int regno)
Otherwise, REGNO specifies which register (so we can save time). */
static void
rs6000_store_inferior_registers (int regno)
rs6000_store_inferior_registers (struct regcache *regcache, int regno)
{
if (regno != -1)
store_register (regno);
store_register (regcache, regno);
else
{
@ -388,25 +388,25 @@ rs6000_store_inferior_registers (int regno)
regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
regno++)
{
store_register (regno);
store_register (regcache, regno);
}
/* Write floating point registers. */
if (tdep->ppc_fp0_regnum >= 0)
for (regno = 0; regno < ppc_num_fprs; regno++)
store_register (tdep->ppc_fp0_regnum + regno);
store_register (regcache, tdep->ppc_fp0_regnum + regno);
/* Write special registers. */
store_register (PC_REGNUM);
store_register (tdep->ppc_ps_regnum);
store_register (tdep->ppc_cr_regnum);
store_register (tdep->ppc_lr_regnum);
store_register (tdep->ppc_ctr_regnum);
store_register (tdep->ppc_xer_regnum);
store_register (regcache, PC_REGNUM);
store_register (regcache, tdep->ppc_ps_regnum);
store_register (regcache, tdep->ppc_cr_regnum);
store_register (regcache, tdep->ppc_lr_regnum);
store_register (regcache, tdep->ppc_ctr_regnum);
store_register (regcache, tdep->ppc_xer_regnum);
if (tdep->ppc_fpscr_regnum >= 0)
store_register (tdep->ppc_fpscr_regnum);
store_register (regcache, tdep->ppc_fpscr_regnum);
if (tdep->ppc_mq_regnum >= 0)
store_register (tdep->ppc_mq_regnum);
store_register (regcache, tdep->ppc_mq_regnum);
}
}

2
gdb/rs6000-tdep.c
View file

@ -1715,7 +1715,7 @@ ran_out_of_registers_for_arguments:
regcache_raw_write_signed (regcache, tdep->ppc_toc_regnum, tocvalue);
}
target_store_registers (-1);
target_store_registers (regcache, -1);
return sp;
}

28
gdb/s390-nat.c
View file

@ -128,7 +128,7 @@ s390_inferior_tid (void)
/* Fetch all general-purpose registers from process/thread TID and
store their values in GDB's register cache. */
static void
fetch_regs (int tid)
fetch_regs (struct regcache *regcache, int tid)
{
gregset_t regs;
ptrace_area parea;
@ -139,13 +139,13 @@ fetch_regs (int tid)
if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea) < 0)
perror_with_name (_("Couldn't get registers"));
supply_gregset (current_regcache, (const gregset_t *) &regs);
supply_gregset (regcache, (const gregset_t *) &regs);
}
/* Store all valid general-purpose registers in GDB's register cache
into the process/thread specified by TID. */
static void
store_regs (int tid, int regnum)
store_regs (const struct regcache *regcache, int tid, int regnum)
{
gregset_t regs;
ptrace_area parea;
@ -156,7 +156,7 @@ store_regs (int tid, int regnum)
if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea) < 0)
perror_with_name (_("Couldn't get registers"));
fill_gregset (current_regcache, &regs, regnum);
fill_gregset (regcache, &regs, regnum);
if (ptrace (PTRACE_POKEUSR_AREA, tid, (long) &parea) < 0)
perror_with_name (_("Couldn't write registers"));
@ -165,7 +165,7 @@ store_regs (int tid, int regnum)
/* Fetch all floating-point registers from process/thread TID and store
their values in GDB's register cache. */
static void
fetch_fpregs (int tid)
fetch_fpregs (struct regcache *regcache, int tid)
{
fpregset_t fpregs;
ptrace_area parea;
@ -176,13 +176,13 @@ fetch_fpregs (int tid)
if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea) < 0)
perror_with_name (_("Couldn't get floating point status"));
supply_fpregset (current_regcache, (const fpregset_t *) &fpregs);
supply_fpregset (regcache, (const fpregset_t *) &fpregs);
}
/* Store all valid floating-point registers in GDB's register cache
into the process/thread specified by TID. */
static void
store_fpregs (int tid, int regnum)
store_fpregs (const struct regcache *regcache, int tid, int regnum)
{
fpregset_t fpregs;
ptrace_area parea;
@ -193,7 +193,7 @@ store_fpregs (int tid, int regnum)
if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea) < 0)
perror_with_name (_("Couldn't get floating point status"));
fill_fpregset (current_regcache, &fpregs, regnum);
fill_fpregset (regcache, &fpregs, regnum);
if (ptrace (PTRACE_POKEUSR_AREA, tid, (long) &parea) < 0)
perror_with_name (_("Couldn't write floating point status"));
@ -202,33 +202,33 @@ store_fpregs (int tid, int regnum)
/* Fetch register REGNUM from the child process. If REGNUM is -1, do
this for all registers. */
static void
s390_linux_fetch_inferior_registers (int regnum)
s390_linux_fetch_inferior_registers (struct regcache *regcache, int regnum)
{
int tid = s390_inferior_tid ();
if (regnum == -1
|| (regnum < S390_NUM_REGS && regmap_gregset[regnum] != -1))
fetch_regs (tid);
fetch_regs (regcache, tid);
if (regnum == -1
|| (regnum < S390_NUM_REGS && regmap_fpregset[regnum] != -1))
fetch_fpregs (tid);
fetch_fpregs (regcache, tid);
}
/* Store register REGNUM back into the child process. If REGNUM is
-1, do this for all registers. */
static void
s390_linux_store_inferior_registers (int regnum)
s390_linux_store_inferior_registers (struct regcache *regcache, int regnum)
{
int tid = s390_inferior_tid ();
if (regnum == -1
|| (regnum < S390_NUM_REGS && regmap_gregset[regnum] != -1))
store_regs (tid, regnum);
store_regs (regcache, tid, regnum);
if (regnum == -1
|| (regnum < S390_NUM_REGS && regmap_fpregset[regnum] != -1))
store_fpregs (tid, regnum);
store_fpregs (regcache, tid, regnum);
}

8
gdb/shnbsd-nat.c
View file

@ -42,7 +42,7 @@
|| (regno) == SR_REGNUM)
static void
shnbsd_fetch_inferior_registers (int regno)
shnbsd_fetch_inferior_registers (struct regcache *regcache, int regno)
{
if (regno == -1 || GETREGS_SUPPLIES (regno))
{
@ -52,7 +52,7 @@ shnbsd_fetch_inferior_registers (int regno)
(PTRACE_TYPE_ARG3) &inferior_registers, 0) == -1)
perror_with_name (_("Couldn't get registers"));
shnbsd_supply_reg (current_regcache, (char *) &inferior_registers, regno);
shnbsd_supply_reg (regcache, (char *) &inferior_registers, regno);
if (regno != -1)
return;
@ -60,7 +60,7 @@ shnbsd_fetch_inferior_registers (int regno)
}
static void
shnbsd_store_inferior_registers (int regno)
shnbsd_store_inferior_registers (struct regcache *regcache, int regno)
{
if (regno == -1 || GETREGS_SUPPLIES (regno))
{
@ -70,7 +70,7 @@ shnbsd_store_inferior_registers (int regno)
(PTRACE_TYPE_ARG3) &inferior_registers, 0) == -1)
perror_with_name (_("Couldn't get registers"));
shnbsd_fill_reg (current_regcache, (char *) &inferior_registers, regno);
shnbsd_fill_reg (regcache, (char *) &inferior_registers, regno);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &inferior_registers, 0) == -1)

38
gdb/sol-thread.c
View file

@ -478,7 +478,7 @@ sol_thread_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
}
static void
sol_thread_fetch_registers (int regnum)
sol_thread_fetch_registers (struct regcache *regcache, int regnum)
{
thread_t thread;
td_thrhandle_t thandle;
@ -494,9 +494,9 @@ sol_thread_fetch_registers (int regnum)
{
/* It's an LWP; pass the request on to procfs. */
if (target_has_execution)
procfs_ops.to_fetch_registers (regnum);
procfs_ops.to_fetch_registers (regcache, regnum);
else
orig_core_ops.to_fetch_registers (regnum);
orig_core_ops.to_fetch_registers (regcache, regnum);
return;
}
@ -531,8 +531,8 @@ sol_thread_fetch_registers (int regnum)
calling the td routines because the td routines call ps_lget*
which affect the values stored in the registers array. */
supply_gregset (current_regcache, (const gdb_gregset_t *) &gregset);
supply_fpregset (current_regcache, (const gdb_fpregset_t *) &fpregset);
supply_gregset (regcache, (const gdb_gregset_t *) &gregset);
supply_fpregset (regcache, (const gdb_fpregset_t *) &fpregset);
#if 0
/* FIXME: libthread_db doesn't seem to handle this right. */
@ -553,7 +553,7 @@ sol_thread_fetch_registers (int regnum)
}
static void
sol_thread_store_registers (int regnum)
sol_thread_store_registers (struct regcache *regcache, int regnum)
{
thread_t thread;
td_thrhandle_t thandle;
@ -568,7 +568,7 @@ sol_thread_store_registers (int regnum)
if (!is_thread (inferior_ptid))
{
/* It's an LWP; pass the request on to procfs.c. */
procfs_ops.to_store_registers (regnum);
procfs_ops.to_store_registers (regcache, regnum);
return;
}
@ -586,7 +586,7 @@ sol_thread_store_registers (int regnum)
char old_value[MAX_REGISTER_SIZE];
/* Save new register value. */
regcache_raw_collect (current_regcache, regnum, old_value);
regcache_raw_collect (regcache, regnum, old_value);
val = p_td_thr_getgregs (&thandle, gregset);
if (val != TD_OK)
@ -598,7 +598,7 @@ sol_thread_store_registers (int regnum)
td_err_string (val));
/* Restore new register value. */
regcache_raw_supply (current_regcache, regnum, old_value);
regcache_raw_supply (regcache, regnum, old_value);
#if 0
/* FIXME: libthread_db doesn't seem to handle this right. */
@ -618,8 +618,8 @@ sol_thread_store_registers (int regnum)
#endif
}
fill_gregset (current_regcache, (gdb_gregset_t *) &gregset, regnum);
fill_fpregset (current_regcache, (gdb_fpregset_t *) &fpregset, regnum);
fill_gregset (regcache, (gdb_gregset_t *) &gregset, regnum);
fill_fpregset (regcache, (gdb_fpregset_t *) &fpregset, regnum);
val = p_td_thr_setgregs (&thandle, gregset);
if (val != TD_OK)
@ -1104,9 +1104,9 @@ ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, prgregset_t gregset)
inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
if (target_has_execution)
procfs_ops.to_fetch_registers (-1);
procfs_ops.to_fetch_registers (current_regcache, -1);
else
orig_core_ops.to_fetch_registers (-1);
orig_core_ops.to_fetch_registers (current_regcache, -1);
fill_gregset (current_regcache, (gdb_gregset_t *) gregset, -1);
do_cleanups (old_chain);
@ -1128,9 +1128,9 @@ ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
supply_gregset (current_regcache, (const gdb_gregset_t *) gregset);
if (target_has_execution)
procfs_ops.to_store_registers (-1);
procfs_ops.to_store_registers (current_regcache, -1);
else
orig_core_ops.to_store_registers (-1);
orig_core_ops.to_store_registers (current_regcache, -1);
do_cleanups (old_chain);
@ -1236,9 +1236,9 @@ ps_lgetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
if (target_has_execution)
procfs_ops.to_fetch_registers (-1);
procfs_ops.to_fetch_registers (current_regcache, -1);
else
orig_core_ops.to_fetch_registers (-1);
orig_core_ops.to_fetch_registers (current_regcache, -1);
fill_fpregset (current_regcache, (gdb_fpregset_t *) fpregset, -1);
do_cleanups (old_chain);
@ -1260,9 +1260,9 @@ ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
supply_fpregset (current_regcache, (const gdb_fpregset_t *) fpregset);
if (target_has_execution)
procfs_ops.to_store_registers (-1);
procfs_ops.to_store_registers (current_regcache, -1);
else
orig_core_ops.to_store_registers (-1);
orig_core_ops.to_store_registers (current_regcache, -1);
do_cleanups (old_chain);

6
gdb/sparc-nat.c
View file

@ -135,9 +135,8 @@ sparc32_fpregset_supplies_p (int regnum)
for all registers (including the floating-point registers). */
void
fetch_inferior_registers (int regnum)
fetch_inferior_registers (struct regcache *regcache, int regnum)
{
struct regcache *regcache = current_regcache;
int pid;
/* NOTE: cagney/2002-12-03: This code assumes that the currently
@ -187,9 +186,8 @@ fetch_inferior_registers (int regnum)
}
void
store_inferior_registers (int regnum)
store_inferior_registers (struct regcache *regcache, int regnum)
{
struct regcache *regcache = current_regcache;
int pid;
/* NOTE: cagney/2002-12-02: See comment in fetch_inferior_registers

14
gdb/spu-linux-nat.c
View file

@ -441,7 +441,7 @@ spu_child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
/* Override the fetch_inferior_register routine. */
static void
spu_fetch_inferior_registers (int regno)
spu_fetch_inferior_registers (struct regcache *regcache, int regno)
{
int fd;
CORE_ADDR addr;
@ -455,7 +455,7 @@ spu_fetch_inferior_registers (int regno)
{
char buf[4];
store_unsigned_integer (buf, 4, fd);
regcache_raw_supply (current_regcache, SPU_ID_REGNUM, buf);
regcache_raw_supply (regcache, SPU_ID_REGNUM, buf);
}
/* The NPC register is found at ADDR. */
@ -463,7 +463,7 @@ spu_fetch_inferior_registers (int regno)
{
gdb_byte buf[4];
if (fetch_ppc_memory (addr, buf, 4) == 0)
regcache_raw_supply (current_regcache, SPU_PC_REGNUM, buf);
regcache_raw_supply (regcache, SPU_PC_REGNUM, buf);
}
/* The GPRs are found in the "regs" spufs file. */
@ -476,13 +476,13 @@ spu_fetch_inferior_registers (int regno)
xsnprintf (annex, sizeof annex, "%d/regs", fd);
if (spu_proc_xfer_spu (annex, buf, NULL, 0, sizeof buf) == sizeof buf)
for (i = 0; i < SPU_NUM_GPRS; i++)
regcache_raw_supply (current_regcache, i, buf + i*16);
regcache_raw_supply (regcache, i, buf + i*16);
}
}
/* Override the store_inferior_register routine. */
static void
spu_store_inferior_registers (int regno)
spu_store_inferior_registers (struct regcache *regcache, int regno)
{
int fd;
CORE_ADDR addr;
@ -495,7 +495,7 @@ spu_store_inferior_registers (int regno)
if (regno == -1 || regno == SPU_PC_REGNUM)
{
gdb_byte buf[4];
regcache_raw_collect (current_regcache, SPU_PC_REGNUM, buf);
regcache_raw_collect (regcache, SPU_PC_REGNUM, buf);
store_ppc_memory (addr, buf, 4);
}
@ -507,7 +507,7 @@ spu_store_inferior_registers (int regno)
int i;
for (i = 0; i < SPU_NUM_GPRS; i++)
regcache_raw_collect (current_regcache, i, buf + i*16);
regcache_raw_collect (regcache, i, buf + i*16);
xsnprintf (annex, sizeof annex, "%d/regs", fd);
spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf);

25
gdb/target.c
View file

@ -106,9 +106,9 @@ static void debug_to_resume (ptid_t, int, enum target_signal);
static ptid_t debug_to_wait (ptid_t, struct target_waitstatus *);
static void debug_to_fetch_registers (int);
static void debug_to_fetch_registers (struct regcache *, int);
static void debug_to_store_registers (int);
static void debug_to_store_registers (struct regcache *, int);
static void debug_to_prepare_to_store (void);
@ -503,10 +503,10 @@ update_current_target (void)
(ptid_t (*) (ptid_t, struct target_waitstatus *))
noprocess);
de_fault (to_fetch_registers,
(void (*) (int))
(void (*) (struct regcache *, int))
target_ignore);
de_fault (to_store_registers,
(void (*) (int))
(void (*) (struct regcache *, int))
noprocess);
de_fault (to_prepare_to_store,
(void (*) (void))
@ -2150,7 +2150,8 @@ debug_to_wait (ptid_t ptid, struct target_waitstatus *status)
}
static void
debug_print_register (const char * func, int regno)
debug_print_register (const char * func,
struct regcache *regcache, int regno)
{
fprintf_unfiltered (gdb_stdlog, "%s ", func);
if (regno >= 0 && regno < NUM_REGS + NUM_PSEUDO_REGS
@ -2162,7 +2163,7 @@ debug_print_register (const char * func, int regno)
{
int i, size = register_size (current_gdbarch, regno);
unsigned char buf[MAX_REGISTER_SIZE];
regcache_cooked_read (current_regcache, regno, buf);
regcache_cooked_read (regcache, regno, buf);
fprintf_unfiltered (gdb_stdlog, " = ");
for (i = 0; i < size; i++)
{
@ -2179,17 +2180,17 @@ debug_print_register (const char * func, int regno)
}
static void
debug_to_fetch_registers (int regno)
debug_to_fetch_registers (struct regcache *regcache, int regno)
{
debug_target.to_fetch_registers (regno);
debug_print_register ("target_fetch_registers", regno);
debug_target.to_fetch_registers (regcache, regno);
debug_print_register ("target_fetch_registers", regcache, regno);
}
static void
debug_to_store_registers (int regno)
debug_to_store_registers (struct regcache *regcache, int regno)
{
debug_target.to_store_registers (regno);
debug_print_register ("target_store_registers", regno);
debug_target.to_store_registers (regcache, regno);
debug_print_register ("target_store_registers", regcache, regno);
fprintf_unfiltered (gdb_stdlog, "\n");
}

13
gdb/target.h
View file

@ -31,6 +31,7 @@ struct ui_file;
struct mem_attrib;
struct target_ops;
struct bp_target_info;
struct regcache;
/* This include file defines the interface between the main part
of the debugger, and the part which is target-specific, or
@ -323,8 +324,8 @@ struct target_ops
void (*to_disconnect) (struct target_ops *, char *, int);
void (*to_resume) (ptid_t, int, enum target_signal);
ptid_t (*to_wait) (ptid_t, struct target_waitstatus *);
void (*to_fetch_registers) (int);
void (*to_store_registers) (int);
void (*to_fetch_registers) (struct regcache *, int);
void (*to_store_registers) (struct regcache *, int);
void (*to_prepare_to_store) (void);
/* Transfer LEN bytes of memory between GDB address MYADDR and
@ -589,15 +590,15 @@ extern void target_disconnect (char *, int);
/* Fetch at least register REGNO, or all regs if regno == -1. No result. */
#define target_fetch_registers(regno) \
(*current_target.to_fetch_registers) (regno)
#define target_fetch_registers(regcache, regno) \
(*current_target.to_fetch_registers) (regcache, regno)
/* Store at least register REGNO, or all regs if REGNO == -1.
It can store as many registers as it wants to, so target_prepare_to_store
must have been previously called. Calls error() if there are problems. */
#define target_store_registers(regs) \
(*current_target.to_store_registers) (regs)
#define target_store_registers(regcache, regs) \
(*current_target.to_store_registers) (regcache, regs)
/* Get ready to modify the registers array. On machines which store
individual registers, this doesn't need to do anything. On machines

8
gdb/vaxbsd-nat.c
View file

@ -65,7 +65,7 @@ vaxbsd_collect_gregset (const struct regcache *regcache,
for all registers. */
static void
vaxbsd_fetch_inferior_registers (int regnum)
vaxbsd_fetch_inferior_registers (struct regcache *regcache, int regnum)
{
struct reg regs;
@ -73,14 +73,14 @@ vaxbsd_fetch_inferior_registers (int regnum)
(PTRACE_TYPE_ARG3) &regs, 0) == -1)
perror_with_name (_("Couldn't get registers"));
vaxbsd_supply_gregset (current_regcache, &regs);
vaxbsd_supply_gregset (regcache, &regs);
}
/* Store register REGNUM back into the inferior. If REGNUM is -1, do
this for all registers. */
static void
vaxbsd_store_inferior_registers (int regnum)
vaxbsd_store_inferior_registers (struct regcache *regcache, int regnum)
{
struct reg regs;
@ -88,7 +88,7 @@ vaxbsd_store_inferior_registers (int regnum)
(PTRACE_TYPE_ARG3) &regs, 0) == -1)
perror_with_name (_("Couldn't get registers"));
vaxbsd_collect_gregset (current_regcache, &regs, regnum);
vaxbsd_collect_gregset (regcache, &regs, regnum);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &regs, 0) == -1)

26
gdb/win32-nat.c
View file

@ -343,7 +343,7 @@ win32_delete_thread (DWORD id)
}
static void
do_win32_fetch_inferior_registers (int r)
do_win32_fetch_inferior_registers (struct regcache *regcache, int r)
{
char *context_offset = ((char *) &current_thread->context) + mappings[r];
long l;
@ -385,58 +385,58 @@ do_win32_fetch_inferior_registers (int r)
if (r == I387_FISEG_REGNUM)
{
l = *((long *) context_offset) & 0xffff;
regcache_raw_supply (current_regcache, r, (char *) &l);
regcache_raw_supply (regcache, r, (char *) &l);
}
else if (r == I387_FOP_REGNUM)
{
l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1);
regcache_raw_supply (current_regcache, r, (char *) &l);
regcache_raw_supply (regcache, r, (char *) &l);
}
else if (r >= 0)
regcache_raw_supply (current_regcache, r, context_offset);
regcache_raw_supply (regcache, r, context_offset);
else
{
for (r = 0; r < NUM_REGS; r++)
do_win32_fetch_inferior_registers (r);
do_win32_fetch_inferior_registers (regcache, r);
}
#undef I387_ST0_REGNUM
}
static void
win32_fetch_inferior_registers (int r)
win32_fetch_inferior_registers (struct regcache *regcache, int r)
{
current_thread = thread_rec (PIDGET (inferior_ptid), TRUE);
/* Check if current_thread exists. Windows sometimes uses a non-existent
thread id in its events */
if (current_thread)
do_win32_fetch_inferior_registers (r);
do_win32_fetch_inferior_registers (regcache, r);
}
static void
do_win32_store_inferior_registers (int r)
do_win32_store_inferior_registers (const struct regcache *regcache, int r)
{
if (!current_thread)
/* Windows sometimes uses a non-existent thread id in its events */;
else if (r >= 0)
regcache_raw_collect (current_regcache, r,
regcache_raw_collect (regcache, r,
((char *) &current_thread->context) + mappings[r]);
else
{
for (r = 0; r < NUM_REGS; r++)
do_win32_store_inferior_registers (r);
do_win32_store_inferior_registers (regcache, r);
}
}
/* Store a new register value into the current thread context */
static void
win32_store_inferior_registers (int r)
win32_store_inferior_registers (struct regcache *regcache, int r)
{
current_thread = thread_rec (PIDGET (inferior_ptid), TRUE);
/* Check if current_thread exists. Windows sometimes uses a non-existent
thread id in its events */
if (current_thread)
do_win32_store_inferior_registers (r);
do_win32_store_inferior_registers (regcache, r);
}
static int psapi_loaded = 0;
@ -1318,7 +1318,7 @@ win32_resume (ptid_t ptid, int step, enum target_signal sig)
if (step)
{
/* Single step by setting t bit */
win32_fetch_inferior_registers (PS_REGNUM);
win32_fetch_inferior_registers (current_regcache, PS_REGNUM);
th->context.EFlags |= FLAG_TRACE_BIT;
}

26
gdb/windows-nat.c
View file

@ -343,7 +343,7 @@ win32_delete_thread (DWORD id)
}
static void
do_win32_fetch_inferior_registers (int r)
do_win32_fetch_inferior_registers (struct regcache *regcache, int r)
{
char *context_offset = ((char *) &current_thread->context) + mappings[r];
long l;
@ -385,58 +385,58 @@ do_win32_fetch_inferior_registers (int r)
if (r == I387_FISEG_REGNUM)
{
l = *((long *) context_offset) & 0xffff;
regcache_raw_supply (current_regcache, r, (char *) &l);
regcache_raw_supply (regcache, r, (char *) &l);
}
else if (r == I387_FOP_REGNUM)
{
l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1);
regcache_raw_supply (current_regcache, r, (char *) &l);
regcache_raw_supply (regcache, r, (char *) &l);
}
else if (r >= 0)
regcache_raw_supply (current_regcache, r, context_offset);
regcache_raw_supply (regcache, r, context_offset);
else
{
for (r = 0; r < NUM_REGS; r++)
do_win32_fetch_inferior_registers (r);
do_win32_fetch_inferior_registers (regcache, r);
}
#undef I387_ST0_REGNUM
}
static void
win32_fetch_inferior_registers (int r)
win32_fetch_inferior_registers (struct regcache *regcache, int r)
{
current_thread = thread_rec (PIDGET (inferior_ptid), TRUE);
/* Check if current_thread exists. Windows sometimes uses a non-existent
thread id in its events */
if (current_thread)
do_win32_fetch_inferior_registers (r);
do_win32_fetch_inferior_registers (regcache, r);
}
static void
do_win32_store_inferior_registers (int r)
do_win32_store_inferior_registers (const struct regcache *regcache, int r)
{
if (!current_thread)
/* Windows sometimes uses a non-existent thread id in its events */;
else if (r >= 0)
regcache_raw_collect (current_regcache, r,
regcache_raw_collect (regcache, r,
((char *) &current_thread->context) + mappings[r]);
else
{
for (r = 0; r < NUM_REGS; r++)
do_win32_store_inferior_registers (r);
do_win32_store_inferior_registers (regcache, r);
}
}
/* Store a new register value into the current thread context */
static void
win32_store_inferior_registers (int r)
win32_store_inferior_registers (struct regcache *regcache, int r)
{
current_thread = thread_rec (PIDGET (inferior_ptid), TRUE);
/* Check if current_thread exists. Windows sometimes uses a non-existent
thread id in its events */
if (current_thread)
do_win32_store_inferior_registers (r);
do_win32_store_inferior_registers (regcache, r);
}
static int psapi_loaded = 0;
@ -1318,7 +1318,7 @@ win32_resume (ptid_t ptid, int step, enum target_signal sig)
if (step)
{
/* Single step by setting t bit */
win32_fetch_inferior_registers (PS_REGNUM);
win32_fetch_inferior_registers (current_regcache, PS_REGNUM);
th->context.EFlags |= FLAG_TRACE_BIT;
}