This is the mail archive of the
gdb-patches@sourceware.org
mailing list for the GDB project.
[rfc] [14/14] Push REGCACHE into target_fetch/store_registers
- From: "Ulrich Weigand" <uweigand at de dot ibm dot com>
- To: gdb-patches at sourceware dot org
- Date: Tue, 1 May 2007 03:31:05 +0200 (CEST)
- Subject: [rfc] [14/14] Push REGCACHE into target_fetch/store_registers
Hello,
this patch finally adds the REGCACHE parameter to the to_fetch_register
and to_store_register callbacks, all their implemenations and some
local helper routines.
It's a big patch, but should be completely mechanical ...
Bye,
Ulrich
ChangeLog:
* 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.
diff -urNp gdb-orig/gdb/aix-thread.c gdb-head/gdb/aix-thread.c
--- gdb-orig/gdb/aix-thread.c 2007-05-01 00:10:26.040247287 +0200
+++ gdb-head/gdb/aix-thread.c 2007-05-01 00:18:57.283289028 +0200
@@ -1270,22 +1270,22 @@ fetch_regs_kernel_thread (struct regcach
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 r
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);
}
}
diff -urNp gdb-orig/gdb/alphabsd-nat.c gdb-head/gdb/alphabsd-nat.c
--- gdb-orig/gdb/alphabsd-nat.c 2007-05-01 00:18:00.342732737 +0200
+++ gdb-head/gdb/alphabsd-nat.c 2007-05-01 00:18:57.288288318 +0200
@@ -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 r
(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 r
(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 r
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 r
(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 r
(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)
diff -urNp gdb-orig/gdb/amd64bsd-nat.c gdb-head/gdb/amd64bsd-nat.c
--- gdb-orig/gdb/amd64bsd-nat.c 2007-04-30 22:55:17.173852528 +0200
+++ gdb-head/gdb/amd64bsd-nat.c 2007-05-01 00:18:57.292287750 +0200
@@ -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 r
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
perror_with_name (_("Couldn't get registers"));
- amd64_supply_native_gregset (current_regcache, ®s, -1);
+ amd64_supply_native_gregset (regcache, ®s, -1);
if (regnum != -1)
return;
}
@@ -64,7 +64,7 @@ amd64bsd_fetch_inferior_registers (int r
(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 r
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 r
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
perror_with_name (_("Couldn't get registers"));
- amd64_collect_native_gregset (current_regcache, ®s, regnum);
+ amd64_collect_native_gregset (regcache, ®s, regnum);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
@@ -100,7 +100,7 @@ amd64bsd_store_inferior_registers (int r
(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)
diff -urNp gdb-orig/gdb/amd64-linux-nat.c gdb-head/gdb/amd64-linux-nat.c
--- gdb-orig/gdb/amd64-linux-nat.c 2007-05-01 00:18:00.356730750 +0200
+++ gdb-head/gdb/amd64-linux-nat.c 2007-05-01 00:18:57.297287041 +0200
@@ -157,7 +157,7 @@ fill_fpregset (const struct regcache *re
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 (in
if (ptrace (PTRACE_GETREGS, tid, 0, (long) ®s) < 0)
perror_with_name (_("Couldn't get registers"));
- amd64_supply_native_gregset (current_regcache, ®s, -1);
+ amd64_supply_native_gregset (regcache, ®s, -1);
if (regnum != -1)
return;
}
@@ -185,7 +185,7 @@ amd64_linux_fetch_inferior_registers (in
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 (in
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 (in
if (ptrace (PTRACE_GETREGS, tid, 0, (long) ®s) < 0)
perror_with_name (_("Couldn't get registers"));
- amd64_collect_native_gregset (current_regcache, ®s, regnum);
+ amd64_collect_native_gregset (regcache, ®s, regnum);
if (ptrace (PTRACE_SETREGS, tid, 0, (long) ®s) < 0)
perror_with_name (_("Couldn't write registers"));
@@ -226,7 +226,7 @@ amd64_linux_store_inferior_registers (in
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"));
diff -urNp gdb-orig/gdb/arm-linux-nat.c gdb-head/gdb/arm-linux-nat.c
--- gdb-orig/gdb/arm-linux-nat.c 2007-05-01 00:18:00.361730040 +0200
+++ gdb-head/gdb/arm-linux-nat.c 2007-05-01 00:18:57.306285764 +0200
@@ -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 *) ®s[regno]);
+ regcache_raw_supply (regcache, regno, (char *) ®s[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 *) ®s[ARM_CPSR_REGNUM]);
else
- regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
+ regcache_raw_supply (regcache, ARM_PS_REGNUM,
(char *) ®s[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 *) ®s[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 *) ®s[regno]);
+ regcache_raw_supply (regcache, regno, (char *) ®s[regno]);
if (arm_apcs_32)
- regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
+ regcache_raw_supply (regcache, ARM_PS_REGNUM,
(char *) ®s[ARM_CPSR_REGNUM]);
else
- regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
+ regcache_raw_supply (regcache, ARM_PS_REGNUM,
(char *) ®s[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 *) ®s[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 *) ®s[regno]);
+ regcache_raw_collect (regcache, regno, (char *) ®s[regno]);
else if (arm_apcs_32 && regno == ARM_PS_REGNUM)
- regcache_raw_collect (current_regcache, regno,
+ regcache_raw_collect (regcache, regno,
(char *) ®s[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 *) ®s[ARM_PC_REGNUM]);
ret = ptrace (PTRACE_SETREGS, tid, 0, ®s);
@@ -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 *) ®s[regno]);
+ if (regcache_valid_p (regcache, regno))
+ regcache_raw_collect (regcache, regno, (char *) ®s[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 *) ®s[ARM_CPSR_REGNUM]);
ret = ptrace (PTRACE_SETREGS, tid, 0, ®s);
@@ -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,
®buf[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,
®buf[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,
®buf[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,
®buf[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,
®buf[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,
®buf[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
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);
}
}
diff -urNp gdb-orig/gdb/armnbsd-nat.c gdb-head/gdb/armnbsd-nat.c
--- gdb-orig/gdb/armnbsd-nat.c 2007-05-01 00:18:50.260222156 +0200
+++ gdb-head/gdb/armnbsd-nat.c 2007-05-01 00:18:57.312284912 +0200
@@ -77,7 +77,7 @@ arm_supply_fparegset (struct regcache *r
}
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);
}
}
diff -urNp gdb-orig/gdb/bsd-kvm.c gdb-head/gdb/bsd-kvm.c
--- gdb-orig/gdb/bsd-kvm.c 2007-04-30 22:55:17.198848980 +0200
+++ gdb-head/gdb/bsd-kvm.c 2007-05-01 00:18:57.317284202 +0200
@@ -91,7 +91,7 @@ bsd_kvm_open (char *filename, int from_t
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 *o
/* 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);
diff -urNp gdb-orig/gdb/bsd-uthread.c gdb-head/gdb/bsd-uthread.c
--- gdb-orig/gdb/bsd-uthread.c 2007-04-30 22:55:17.203848271 +0200
+++ gdb-head/gdb/bsd-uthread.c 2007-05-01 00:18:57.322283493 +0200
@@ -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);
}
}
diff -urNp gdb-orig/gdb/corelow.c gdb-head/gdb/corelow.c
--- gdb-orig/gdb/corelow.c 2007-05-01 00:18:50.265221447 +0200
+++ gdb-head/gdb/corelow.c 2007-05-01 00:18:57.327282783 +0200
@@ -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 regcac
/* 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 ();
diff -urNp gdb-orig/gdb/gnu-nat.c gdb-head/gdb/gnu-nat.c
--- gdb-orig/gdb/gnu-nat.c 2007-04-30 22:55:17.282837060 +0200
+++ gdb-head/gdb/gnu-nat.c 2007-05-01 00:18:57.336281506 +0200
@@ -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;
diff -urNp gdb-orig/gdb/go32-nat.c gdb-head/gdb/go32-nat.c
--- gdb-orig/gdb/go32-nat.c 2007-05-01 00:10:35.027300359 +0200
+++ gdb-head/gdb/go32-nat.c 2007-05-01 00:18:57.343280512 +0200
@@ -174,9 +174,9 @@ static void go32_resume (ptid_t ptid, in
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_wa
}
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);
}
}
diff -urNp gdb-orig/gdb/hppabsd-nat.c gdb-head/gdb/hppabsd-nat.c
--- gdb-orig/gdb/hppabsd-nat.c 2007-04-30 22:55:17.337829255 +0200
+++ gdb-head/gdb/hppabsd-nat.c 2007-05-01 00:18:57.348279803 +0200
@@ -124,10 +124,8 @@ hppabsd_collect_fpregset (struct regcach
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) ®s, 0) == -1)
perror_with_name (_("Couldn't get registers"));
- hppabsd_collect_gregset (current_regcache, ®s, regnum);
+ hppabsd_collect_gregset (regcache, ®s, regnum);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 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)
diff -urNp gdb-orig/gdb/hppa-hpux-nat.c gdb-head/gdb/hppa-hpux-nat.c
--- gdb-orig/gdb/hppa-hpux-nat.c 2007-04-30 22:55:17.342828546 +0200
+++ gdb-head/gdb/hppa-hpux-nat.c 2007-05-01 00:18:57.352279235 +0200
@@ -87,7 +87,7 @@ hppa_hpux_save_state_offset (struct regc
#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
diff -urNp gdb-orig/gdb/hppa-linux-nat.c gdb-head/gdb/hppa-linux-nat.c
--- gdb-orig/gdb/hppa-linux-nat.c 2007-05-01 00:18:00.374728195 +0200
+++ gdb-head/gdb/hppa-linux-nat.c 2007-05-01 00:18:57.357278525 +0200
@@ -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
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);
}
}
diff -urNp gdb-orig/gdb/hpux-thread.c gdb-head/gdb/hpux-thread.c
--- gdb-orig/gdb/hpux-thread.c 2007-04-30 22:55:17.353826985 +0200
+++ gdb-head/gdb/hpux-thread.c 2007-05-01 00:18:57.362277816 +0200
@@ -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));
}
diff -urNp gdb-orig/gdb/i386bsd-nat.c gdb-head/gdb/i386bsd-nat.c
--- gdb-orig/gdb/i386bsd-nat.c 2007-04-30 22:55:17.358826275 +0200
+++ gdb-head/gdb/i386bsd-nat.c 2007-05-01 00:18:57.367277106 +0200
@@ -132,7 +132,7 @@ i386bsd_collect_gregset (const struct re
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 re
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
perror_with_name (_("Couldn't get registers"));
- i386bsd_supply_gregset (current_regcache, ®s);
+ i386bsd_supply_gregset (regcache, ®s);
if (regnum != -1)
return;
}
@@ -158,7 +158,7 @@ i386bsd_fetch_inferior_registers (int re
(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 re
(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 re
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 re
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
perror_with_name (_("Couldn't get registers"));
- i386bsd_collect_gregset (current_regcache, ®s, regnum);
+ i386bsd_collect_gregset (regcache, ®s, regnum);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
@@ -214,7 +214,7 @@ i386bsd_store_inferior_registers (int re
{
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 re
(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)
diff -urNp gdb-orig/gdb/i386gnu-nat.c gdb-head/gdb/i386gnu-nat.c
--- gdb-orig/gdb/i386gnu-nat.c 2007-05-01 00:18:00.379727486 +0200
+++ gdb-head/gdb/i386gnu-nat.c 2007-05-01 00:18:57.372276397 +0200
@@ -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 *regcac
/* 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 r
/* 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 r
/* 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);
}
}
diff -urNp gdb-orig/gdb/i386-linux-nat.c gdb-head/gdb/i386-linux-nat.c
--- gdb-orig/gdb/i386-linux-nat.c 2007-05-01 00:18:00.385726634 +0200
+++ gdb-head/gdb/i386-linux-nat.c 2007-05-01 00:18:57.379275403 +0200
@@ -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 *reg
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 *) ®s);
+ supply_gregset (regcache, (const elf_gregset_t *) ®s);
}
/* 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) ®s) < 0)
perror_with_name (_("Couldn't get registers"));
- fill_gregset (current_regcache, ®s, regno);
+ fill_gregset (regcache, ®s, regno);
if (ptrace (PTRACE_SETREGS, tid, 0, (int) ®s) < 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 *re
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 *r
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 r
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
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
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
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
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
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
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;
}
diff -urNp gdb-orig/gdb/ia64-linux-nat.c gdb-head/gdb/ia64-linux-nat.c
--- gdb-orig/gdb/ia64-linux-nat.c 2007-05-01 00:18:00.399724647 +0200
+++ gdb-head/gdb/ia64-linux-nat.c 2007-05-01 00:18:57.385274552 +0200
@@ -666,7 +666,7 @@ ia64_linux_can_use_hw_breakpoint (int ty
/* 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);
}
diff -urNp gdb-orig/gdb/ia64-tdep.c gdb-head/gdb/ia64-tdep.c
--- gdb-orig/gdb/ia64-tdep.c 2007-04-30 22:55:17.409819038 +0200
+++ gdb-head/gdb/ia64-tdep.c 2007-05-01 00:18:57.395273132 +0200
@@ -3540,7 +3540,7 @@ ia64_store_return_value (struct type *ty
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);
diff -urNp gdb-orig/gdb/inf-child.c gdb-head/gdb/inf-child.c
--- gdb-orig/gdb/inf-child.c 2007-04-30 22:55:17.450813220 +0200
+++ gdb-head/gdb/inf-child.c 2007-05-01 00:18:57.399272565 +0200
@@ -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)
{
}
diff -urNp gdb-orig/gdb/inferior.h gdb-head/gdb/inferior.h
--- gdb-orig/gdb/inferior.h 2007-04-30 22:55:17.454812652 +0200
+++ gdb-head/gdb/inferior.h 2007-05-01 00:18:57.404271855 +0200
@@ -209,9 +209,9 @@ extern void default_print_registers_info
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);
diff -urNp gdb-orig/gdb/inf-ptrace.c gdb-head/gdb/inf-ptrace.c
--- gdb-orig/gdb/inf-ptrace.c 2007-04-30 22:55:17.459811943 +0200
+++ gdb-head/gdb/inf-ptrace.c 2007-05-01 00:18:57.409271145 +0200
@@ -617,7 +617,7 @@ static CORE_ADDR (*inf_ptrace_register_u
/* 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
diff -urNp gdb-orig/gdb/infptrace.c gdb-head/gdb/infptrace.c
--- gdb-orig/gdb/infptrace.c 2007-04-30 22:55:17.464811233 +0200
+++ gdb-head/gdb/infptrace.c 2007-05-01 00:18:57.414270436 +0200
@@ -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. */
diff -urNp gdb-orig/gdb/linux-nat.c gdb-head/gdb/linux-nat.c
--- gdb-orig/gdb/linux-nat.c 2007-05-01 00:18:00.415722376 +0200
+++ gdb-head/gdb/linux-nat.c 2007-05-01 00:18:57.423269158 +0200
@@ -2650,8 +2650,8 @@ linux_nat_corefile_thread_callback (stru
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 (stru
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_
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),
diff -urNp gdb-orig/gdb/m32r-linux-nat.c gdb-head/gdb/m32r-linux-nat.c
--- gdb-orig/gdb/m32r-linux-nat.c 2007-05-01 00:18:00.420721667 +0200
+++ gdb-head/gdb/m32r-linux-nat.c 2007-05-01 00:18:57.439266888 +0200
@@ -108,14 +108,14 @@ supply_gregset (struct regcache *regcach
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) ®s) < 0)
perror_with_name (_("Couldn't get registers"));
- supply_gregset (current_regcache, (const elf_gregset_t *) ®s);
+ supply_gregset (regcache, (const elf_gregset_t *) ®s);
}
/* Fill register REGNO (if it is a general-purpose register) in
@@ -157,14 +157,14 @@ fill_gregset (const struct regcache *reg
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) ®s) < 0)
perror_with_name (_("Couldn't get registers"));
- fill_gregset (current_regcache, ®s, regno);
+ fill_gregset (regcache, ®s, regno);
if (ptrace (PTRACE_SETREGS, tid, 0, (int) ®s) < 0)
perror_with_name (_("Couldn't write registers"));
@@ -195,7 +195,7 @@ fill_fpregset (const struct regcache *re
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
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
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
transfers more registers in one system call. */
if (regno == -1 || GETREGS_SUPPLIES (regno))
{
- store_regs (tid, regno);
+ store_regs (regcache, tid, regno);
return;
}
diff -urNp gdb-orig/gdb/m68kbsd-nat.c gdb-head/gdb/m68kbsd-nat.c
--- gdb-orig/gdb/m68kbsd-nat.c 2007-04-30 22:55:17.495806834 +0200
+++ gdb-head/gdb/m68kbsd-nat.c 2007-05-01 00:18:57.444266178 +0200
@@ -108,7 +108,7 @@ m68kbsd_collect_fpregset (struct regcach
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 re
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
perror_with_name (_("Couldn't get registers"));
- m68kbsd_supply_gregset (current_regcache, ®s);
+ m68kbsd_supply_gregset (regcache, ®s);
}
if (regnum == -1 || m68kbsd_fpregset_supplies_p (regnum))
@@ -129,7 +129,7 @@ m68kbsd_fetch_inferior_registers (int re
(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 re
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 re
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
perror_with_name (_("Couldn't get registers"));
- m68kbsd_collect_gregset (current_regcache, ®s, regnum);
+ m68kbsd_collect_gregset (regcache, ®s, regnum);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
@@ -162,7 +162,7 @@ m68kbsd_store_inferior_registers (int re
(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)
diff -urNp gdb-orig/gdb/m68klinux-nat.c gdb-head/gdb/m68klinux-nat.c
--- gdb-orig/gdb/m68klinux-nat.c 2007-05-01 00:18:50.329212364 +0200
+++ gdb-head/gdb/m68klinux-nat.c 2007-05-01 00:18:57.450265326 +0200
@@ -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 *reg
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 *) ®s);
+ supply_gregset (regcache, (const elf_gregset_t *) ®s);
}
/* 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) ®s) < 0)
perror_with_name (_("Couldn't get registers"));
- fill_gregset (current_regcache, ®s, regno);
+ fill_gregset (regcache, ®s, regno);
if (ptrace (PTRACE_SETREGS, tid, 0, (int) ®s) < 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 *re
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 r
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
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
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
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
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
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;
}
diff -urNp gdb-orig/gdb/m88kbsd-nat.c gdb-head/gdb/m88kbsd-nat.c
--- gdb-orig/gdb/m88kbsd-nat.c 2007-04-30 22:55:17.506805273 +0200
+++ gdb-head/gdb/m88kbsd-nat.c 2007-05-01 00:18:57.454264759 +0200
@@ -65,7 +65,7 @@ m88kbsd_collect_gregset (const struct re
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 re
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
perror_with_name (_("Couldn't get registers"));
- m88kbsd_supply_gregset (current_regcache, ®s);
+ m88kbsd_supply_gregset (regcache, ®s);
}
/* 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 re
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
perror_with_name (_("Couldn't get registers"));
- m88kbsd_collect_gregset (current_regcache, ®s, regnum);
+ m88kbsd_collect_gregset (regcache, ®s, regnum);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
diff -urNp gdb-orig/gdb/mips64obsd-nat.c gdb-head/gdb/mips64obsd-nat.c
--- gdb-orig/gdb/mips64obsd-nat.c 2007-04-30 22:55:17.558797894 +0200
+++ gdb-head/gdb/mips64obsd-nat.c 2007-05-01 00:18:57.458264191 +0200
@@ -79,7 +79,7 @@ mips64obsd_collect_gregset (const struct
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
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
perror_with_name (_("Couldn't get registers"));
- mips64obsd_supply_gregset (current_regcache, ®s);
+ mips64obsd_supply_gregset (regcache, ®s);
}
/* 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
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
perror_with_name (_("Couldn't get registers"));
- mips64obsd_collect_gregset (current_regcache, ®s, regnum);
+ mips64obsd_collect_gregset (regcache, ®s, regnum);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
diff -urNp gdb-orig/gdb/mips-linux-nat.c gdb-head/gdb/mips-linux-nat.c
--- gdb-orig/gdb/mips-linux-nat.c 2007-05-01 00:18:00.442718544 +0200
+++ gdb-head/gdb/mips-linux-nat.c 2007-05-01 00:18:57.463263481 +0200
@@ -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 *re
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 (in
perror_with_name (_("Couldn't get registers"));
}
- mips64_supply_gregset (current_regcache,
+ mips64_supply_gregset (regcache,
(const mips64_elf_gregset_t *) ®s);
}
@@ -271,7 +271,7 @@ mips64_linux_regsets_fetch_registers (in
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 (in
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 (in
if (ptrace (PTRACE_GETREGS, tid, 0L, (PTRACE_TYPE_ARG3) ®s) == -1)
perror_with_name (_("Couldn't get registers"));
- mips64_fill_gregset (current_regcache, ®s, regno);
+ mips64_fill_gregset (regcache, ®s, regno);
if (ptrace (PTRACE_SETREGS, tid, 0L, (PTRACE_TYPE_ARG3) ®s) == -1)
perror_with_name (_("Couldn't set registers"));
@@ -320,7 +320,7 @@ mips64_linux_regsets_store_registers (in
(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 (in
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
diff -urNp gdb-orig/gdb/mipsnbsd-nat.c gdb-head/gdb/mipsnbsd-nat.c
--- gdb-orig/gdb/mipsnbsd-nat.c 2007-05-01 00:10:38.849421556 +0200
+++ gdb-head/gdb/mipsnbsd-nat.c 2007-05-01 00:18:57.467262914 +0200
@@ -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 r
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
perror_with_name (_("Couldn't get registers"));
- mipsnbsd_supply_reg (current_regcache, (char *) ®s, regno);
+ mipsnbsd_supply_reg (regcache, (char *) ®s, regno);
if (regno != -1)
return;
}
@@ -63,12 +63,12 @@ mipsnbsd_fetch_inferior_registers (int r
(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 r
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
perror_with_name (_("Couldn't get registers"));
- mipsnbsd_fill_reg (current_regcache, (char *) ®s, regno);
+ mipsnbsd_fill_reg (regcache, (char *) ®s, regno);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
@@ -96,7 +96,7 @@ mipsnbsd_store_inferior_registers (int r
(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)
diff -urNp gdb-orig/gdb/monitor.c gdb-head/gdb/monitor.c
--- gdb-orig/gdb/monitor.c 2007-05-01 00:10:41.123365468 +0200
+++ gdb-head/gdb/monitor.c 2007-05-01 00:18:57.475261778 +0200
@@ -1129,7 +1129,7 @@ monitor_wait (ptid_t ptid, struct target
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 *regc
}
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
diff -urNp gdb-orig/gdb/nto-procfs.c gdb-head/gdb/nto-procfs.c
--- gdb-orig/gdb/nto-procfs.c 2007-05-01 00:10:43.814381527 +0200
+++ gdb-head/gdb/nto-procfs.c 2007-05-01 00:18:57.481260927 +0200
@@ -67,7 +67,7 @@ static int procfs_xfer_memory (CORE_ADDR
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_
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, ®, sizeof (reg), ®size) == EOK)
- nto_supply_gregset (current_regcache, (char *) ®.greg);
+ nto_supply_gregset (regcache, (char *) ®.greg);
if (devctl (ctl_fd, DCMD_PROC_GETFPREG, ®, sizeof (reg), ®size)
== EOK)
- nto_supply_fpregset (current_regcache, (char *) ®.fpreg);
+ nto_supply_fpregset (regcache, (char *) ®.fpreg);
if (devctl (ctl_fd, DCMD_PROC_GETALTREG, ®, sizeof (reg), ®size)
== EOK)
- nto_supply_altregset (current_regcache, (char *) ®.altreg);
+ nto_supply_altregset (regcache, (char *) ®.altreg);
}
/* Copy LEN bytes to/from inferior's memory starting at MEMADDR
@@ -1147,7 +1147,7 @@ get_regset (int regset, char *buf, int b
}
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 *) ®) == -1)
+ if (nto_regset_fill (regcache, regset, (char *) ®) == -1)
continue;
err = devctl (ctl_fd, dev_set, ®, regsize, 0);
@@ -1198,7 +1198,7 @@ procfs_store_registers (int regno)
if (len < 1)
return;
- regcache_raw_collect (current_regcache, regno, (char *) ® + off);
+ regcache_raw_collect (regcache, regno, (char *) ® + off);
err = devctl (ctl_fd, dev_set, ®, regsize, 0);
if (err != EOK)
diff -urNp gdb-orig/gdb/ppc-linux-nat.c gdb-head/gdb/ppc-linux-nat.c
--- gdb-orig/gdb/ppc-linux-nat.c 2007-05-01 00:18:00.448717693 +0200
+++ gdb-head/gdb/ppc-linux-nat.c 2007-05-01 00:18:57.490259649 +0200
@@ -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 reg
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_e
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 *vrregse
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 (®s);
+ supply_vrregset (regcache, ®s);
}
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
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 reg
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, ®s);
@@ -571,7 +571,7 @@ set_spe_registers (int tid, struct gdb_e
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 (®s);
+ fill_vrregset (regcache, ®s);
if (ptrace (PTRACE_SETVRREGS, tid, 0, ®s) < 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
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 *reg
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 *re
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));
}
}
diff -urNp gdb-orig/gdb/ppcnbsd-nat.c gdb-head/gdb/ppcnbsd-nat.c
--- gdb-orig/gdb/ppcnbsd-nat.c 2007-04-30 22:55:17.638786541 +0200
+++ gdb-head/gdb/ppcnbsd-nat.c 2007-05-01 00:18:57.494259082 +0200
@@ -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 re
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
perror_with_name (_("Couldn't get registers"));
- ppc_supply_gregset (&ppcnbsd_gregset, current_regcache,
+ ppc_supply_gregset (&ppcnbsd_gregset, regcache,
regnum, ®s, sizeof regs);
}
@@ -102,13 +102,13 @@ ppcnbsd_fetch_inferior_registers (int re
(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 re
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
perror_with_name (_("Couldn't get registers"));
- ppc_collect_gregset (&ppcnbsd_gregset, current_regcache,
+ ppc_collect_gregset (&ppcnbsd_gregset, regcache,
regnum, ®s, sizeof regs);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
@@ -134,7 +134,7 @@ ppcnbsd_store_inferior_registers (int re
(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),
diff -urNp gdb-orig/gdb/ppcobsd-nat.c gdb-head/gdb/ppcobsd-nat.c
--- gdb-orig/gdb/ppcobsd-nat.c 2007-04-30 22:55:17.642785974 +0200
+++ gdb-head/gdb/ppcobsd-nat.c 2007-05-01 00:18:57.498258514 +0200
@@ -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) ®s, 0) == -1)
perror_with_name (_("Couldn't get registers"));
- ppc_supply_gregset (&ppcobsd_gregset, current_regcache, -1,
+ ppc_supply_gregset (&ppcobsd_gregset, regcache, -1,
®s, sizeof regs);
#ifndef PT_GETFPREGS
- ppc_supply_fpregset (&ppcobsd_gregset, current_regcache, -1,
+ ppc_supply_fpregset (&ppcobsd_gregset, regcache, -1,
®s, 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) ®s, 0) == -1)
perror_with_name (_("Couldn't get registers"));
- ppc_collect_gregset (&ppcobsd_gregset, current_regcache,
+ ppc_collect_gregset (&ppcobsd_gregset, regcache,
regnum, ®s, sizeof regs);
#ifndef PT_GETFPREGS
- ppc_collect_fpregset (&ppcobsd_gregset, current_regcache,
+ ppc_collect_fpregset (&ppcobsd_gregset, regcache,
regnum, ®s, 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),
diff -urNp gdb-orig/gdb/procfs.c gdb-head/gdb/procfs.c
--- gdb-orig/gdb/procfs.c 2007-05-01 00:18:00.461715848 +0200
+++ gdb-head/gdb/procfs.c 2007-05-01 00:18:57.511256669 +0200
@@ -120,8 +120,8 @@ static void procfs_resume (ptid_t, int,
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__);
}
diff -urNp gdb-orig/gdb/proc-service.c gdb-head/gdb/proc-service.c
--- gdb-orig/gdb/proc-service.c 2007-05-01 00:18:00.467714996 +0200
+++ gdb-head/gdb/proc-service.c 2007-05-01 00:18:57.516255959 +0200
@@ -234,7 +234,7 @@ ps_lgetregs (gdb_ps_prochandle_t ph, lwp
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, lwp
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, l
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, l
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;
diff -urNp gdb-orig/gdb/regcache.c gdb-head/gdb/regcache.c
--- gdb-orig/gdb/regcache.c 2007-04-30 22:55:17.666917736 +0200
+++ gdb-head/gdb/regcache.c 2007-05-01 00:18:57.522255108 +0200
@@ -508,8 +508,8 @@ regcache_raw_read (struct regcache *regc
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 *reg
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
diff -urNp gdb-orig/gdb/remote.c gdb-head/gdb/remote.c
--- gdb-orig/gdb/remote.c 2007-04-30 22:55:17.681915607 +0200
+++ gdb-head/gdb/remote.c 2007-05-01 00:18:57.536253121 +0200
@@ -91,7 +91,7 @@ static void remote_files_info (struct ta
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,
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_re
/* 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_re
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_re
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_re
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;
}
diff -urNp gdb-orig/gdb/remote-m32r-sdi.c gdb-head/gdb/remote-m32r-sdi.c
--- gdb-orig/gdb/remote-m32r-sdi.c 2007-04-30 22:55:17.690914330 +0200
+++ gdb-head/gdb/remote-m32r-sdi.c 2007-05-01 00:18:57.543252127 +0200
@@ -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, ®val);
+ regcache_cooked_read_unsigned (regcache, regno, ®val);
regid = get_reg_id (regno);
if (regid == SDI_REG_PSW)
diff -urNp gdb-orig/gdb/remote-mips.c gdb-head/gdb/remote-mips.c
--- gdb-orig/gdb/remote-mips.c 2007-04-30 22:55:17.705912201 +0200
+++ gdb-head/gdb/remote-mips.c 2007-05-01 00:18:57.552250850 +0200
@@ -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));
diff -urNp gdb-orig/gdb/remote-sim.c gdb-head/gdb/remote-sim.c
--- gdb-orig/gdb/remote-sim.c 2007-04-30 22:55:17.711911350 +0200
+++ gdb-head/gdb/remote-sim.c 2007-05-01 00:18:57.558249999 +0200
@@ -73,9 +73,9 @@ static void gdb_os_evprintf_filtered (ho
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));
diff -urNp gdb-orig/gdb/rs6000-nat.c gdb-head/gdb/rs6000-nat.c
--- gdb-orig/gdb/rs6000-nat.c 2007-04-30 22:55:17.718910357 +0200
+++ gdb-head/gdb/rs6000-nat.c 2007-05-01 00:18:57.564249147 +0200
@@ -210,7 +210,7 @@ rs6000_ptrace64 (int req, int id, long l
/* 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 reg
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 reg
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 reg
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);
}
}
diff -urNp gdb-orig/gdb/rs6000-tdep.c gdb-head/gdb/rs6000-tdep.c
--- gdb-orig/gdb/rs6000-tdep.c 2007-04-30 22:55:17.728908938 +0200
+++ gdb-head/gdb/rs6000-tdep.c 2007-05-01 00:18:57.575247586 +0200
@@ -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;
}
diff -urNp gdb-orig/gdb/s390-nat.c gdb-head/gdb/s390-nat.c
--- gdb-orig/gdb/s390-nat.c 2007-05-01 00:18:00.472714287 +0200
+++ gdb-head/gdb/s390-nat.c 2007-05-01 00:18:57.580246876 +0200
@@ -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 *) ®s);
+ supply_gregset (regcache, (const gregset_t *) ®s);
}
/* 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, ®s, regnum);
+ fill_gregset (regcache, ®s, 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);
}
diff -urNp gdb-orig/gdb/shnbsd-nat.c gdb-head/gdb/shnbsd-nat.c
--- gdb-orig/gdb/shnbsd-nat.c 2007-05-01 00:10:45.325432732 +0200
+++ gdb-head/gdb/shnbsd-nat.c 2007-05-01 00:18:57.584246309 +0200
@@ -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 reg
(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 reg
}
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 reg
(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)
diff -urNp gdb-orig/gdb/sol-thread.c gdb-head/gdb/sol-thread.c
--- gdb-orig/gdb/sol-thread.c 2007-05-01 00:18:00.478713435 +0200
+++ gdb-head/gdb/sol-thread.c 2007-05-01 00:18:57.591245315 +0200
@@ -478,7 +478,7 @@ sol_thread_wait (ptid_t ptid, struct tar
}
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, lwp
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, lwp
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, l
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, l
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);
diff -urNp gdb-orig/gdb/sparc-nat.c gdb-head/gdb/sparc-nat.c
--- gdb-orig/gdb/sparc-nat.c 2007-04-30 22:55:17.768903261 +0200
+++ gdb-head/gdb/sparc-nat.c 2007-05-01 00:18:57.596244605 +0200
@@ -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
diff -urNp gdb-orig/gdb/spu-linux-nat.c gdb-head/gdb/spu-linux-nat.c
--- gdb-orig/gdb/spu-linux-nat.c 2007-04-30 22:55:17.776902126 +0200
+++ gdb-head/gdb/spu-linux-nat.c 2007-05-01 00:18:57.601243896 +0200
@@ -441,7 +441,7 @@ spu_child_wait (ptid_t ptid, struct targ
/* 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);
diff -urNp gdb-orig/gdb/target.c gdb-head/gdb/target.c
--- gdb-orig/gdb/target.c 2007-04-30 22:55:17.787900565 +0200
+++ gdb-head/gdb/target.c 2007-05-01 00:18:57.609242760 +0200
@@ -106,9 +106,9 @@ static void debug_to_resume (ptid_t, int
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 targe
}
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 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,
}
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");
}
diff -urNp gdb-orig/gdb/target.h gdb-head/gdb/target.h
--- gdb-orig/gdb/target.h 2007-04-30 22:55:17.794899572 +0200
+++ gdb-head/gdb/target.h 2007-05-01 00:18:57.616241767 +0200
@@ -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 *, i
/* 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
diff -urNp gdb-orig/gdb/vaxbsd-nat.c gdb-head/gdb/vaxbsd-nat.c
--- gdb-orig/gdb/vaxbsd-nat.c 2007-04-30 22:55:17.798899004 +0200
+++ gdb-head/gdb/vaxbsd-nat.c 2007-05-01 00:18:57.620241199 +0200
@@ -65,7 +65,7 @@ vaxbsd_collect_gregset (const struct reg
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 reg
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
perror_with_name (_("Couldn't get registers"));
- vaxbsd_supply_gregset (current_regcache, ®s);
+ vaxbsd_supply_gregset (regcache, ®s);
}
/* 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 reg
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
perror_with_name (_("Couldn't get registers"));
- vaxbsd_collect_gregset (current_regcache, ®s, regnum);
+ vaxbsd_collect_gregset (regcache, ®s, regnum);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
diff -urNp gdb-orig/gdb/win32-nat.c gdb-head/gdb/win32-nat.c
--- gdb-orig/gdb/win32-nat.c 2007-05-01 00:18:50.343210377 +0200
+++ gdb-head/gdb/win32-nat.c 2007-05-01 00:18:57.628240064 +0200
@@ -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 *) ¤t_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 *) ¤t_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, enu
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;
}
--
Dr. Ulrich Weigand
GNU Toolchain for Linux on System z and Cell BE
Ulrich.Weigand@de.ibm.com