]> git.ipfire.org Git - thirdparty/binutils-gdb.git/commitdiff
Pass ptid to target_fetch_registers
authorSimon Marchi <simon.marchi@ericsson.com>
Tue, 7 Feb 2017 20:17:13 +0000 (15:17 -0500)
committerSimon Marchi <simon.marchi@ericsson.com>
Tue, 7 Mar 2017 21:47:23 +0000 (16:47 -0500)
This patch adds a ptid parameter to the target_fetch_registers and the
to_fetch_registers method of target_ops.  The implementations are
therefore expected to rely on this and not on inferior_ptid.

gdb/ChangeLog:

* target-delegates.c: Re-generate.
* target.h (struct target_ops) <to_fetch_registers>: Add ptid
parameter.
(target_fetch_registers): Likewise.
* target.c (target_fetch_registers): Likewise.
* aarch64-linux-nat.c (fetch_gregs_from_thread,
fetch_fpregs_from_thread,
aarch64_linux_fetch_inferior_registers): Add ptid parameter and
use it.
* aix-thread.c (aix_thread_fetch_registers): Likewise.
* alpha-bsd-nat.c (alphabsd_fetch_inferior_registers): Likewise.
* amd64-bsd-nat.c (amd64bsd_fetch_inferior_registers): Likewise.
* amd64-linux-nat.c (amd64_linux_fetch_inferior_registers):
Likewise.
* arm-linux-nat.c (fetch_fpregs, fetch_regs, fetch_wmmx_regs,
fetch_vfp_regs, arm_linux_fetch_inferior_registers): Likewise.
* arm-nbsd-nat.c (fetch_register, fetch_regs,
fetch_fp_register, fetch_fp_regs, armnbsd_fetch_registers):
Likewise.
* bsd-kvm.c (bsd_kvm_fetch_registers): Likewise.
* bsd-uthread.c (bsd_uthread_fetch_registers): Likewise.
* corelow.c (core_open): Pass inferior_ptid to
target_fetch_registers.
(get_core_registers): Add ptid parameter and use it.
* ctf.c (ctf_fetch_registers): Likewise.
* fbsd-tdep.c (fbsd_corefile_thread): Don't set/restore
inferior_ptid, pass ptid to target_fetch_registers.
* go32-nat.c (go32_fetch_registers): Add ptid parameter and use
it.
* hppa-linux-nat.c (fetch_register,
hppa_linux_fetch_inferior_registers): Likewise.
* hppa-nbsd-nat.c (hppanbsd_fetch_registers): Likewise.
* hppa-obsd-nat.c (hppaobsd_fetch_registers): Likewise.
* i386-bsd-nat.c (i386bsd_fetch_inferior_registers): Likewise.
* i386-darwin-nat.c (i386_darwin_fetch_inferior_registers):
Likewise.
* i386-gnu-nat.c (gnu_fetch_registers): Likewise.
* i386-linux-nat.c (fetch_register,
i386_linux_fetch_inferior_registers): Likewise.
* ia64-linux-nat.c (ia64_linux_fetch_register,
ia64_linux_fetch_registers): Likewise.
* inf-child.c (inf_child_fetch_inferior_registers): Likewise.
* inf-ptrace.c (inf_ptrace_fetch_register,
inf_ptrace_fetch_registers): Likewise.
* linux-tdep.c (linux_corefile_thread): Pass ptid to
target_fetch_registers, don't set/restore inferior_ptid.
* m32r-linux-nat.c (m32r_linux_fetch_inferior_registers):
Add ptid parameter and use it.
* m68k-bsd-nat.c (m68kbsd_fetch_inferior_registers): Likewise.
* m68k-linux-nat.c (fetch_register,
old_fetch_inferior_register,
m68k_linux_fetch_inferior_registers): Likewise.
* m88k-bsd-nat.c (m88kbsd_fetch_inferior_registers): Likewise.
* mips-fbsd-nat.c (mips_fbsd_fetch_inferior_registers):
Likewise.
* mips-linux-nat.c (super_fetch_registers,
mips64_linux_regsets_fetch_registers,
mips64_linux_fetch_registers): Likewise.
* mips-nbsd-nat.c (mipsnbsd_fetch_inferior_registers): Likewise.
* mips-obsd-nat.c (mips64obsd_fetch_inferior_registers):
Likewise.
* nto-procfs.c (procfs_fetch_registers): Likewise.
* ppc-fbsd-nat.c (ppcfbsd_fetch_inferior_registers): Likewise.
* ppc-linux-nat.c (ppc_linux_fetch_inferior_registers):
Likewise.
* ppc-nbsd-nat.c (ppcnbsd_fetch_inferior_registers): Likewise.
* ppc-obsd-nat.c (ppcobsd_fetch_registers): Likewise.
* ppc-ravenscar-thread.c (ppc_ravenscar_generic_fetch_registers,
ppc_ravenscar_powerpc_fetch_registers,
ppc_ravenscar_e500_fetch_registers): Likewise.
* proc-service.c (ps_lgetregs, ps_lgetfpregs): Pass ptid directly
to target_fetch_registers, don't use inferior_ptid.
* procfs.c (procfs_fetch_registers): Add ptid parameter and use
it.
* ravenscar-thread.c (ravenscar_fetch_registers): Add ptid
parameter and use it.  Remove declaration at top of file.
* ravenscar-thread.h (struct ravenscar_arch_ops)
<to_fetch_registers): Add ptid_t parameter.
* record-btrace.c (record_btrace_fetch_registers): Add ptid
parameter and use it.
* record-full.c (record_full_core_open_1): Pass inferior_ptid to
target_fetch_registers.
(record_full_core_fetch_registers): Add ptid parameter.
* regcache.c (regcache_raw_update): Pass inferior_ptid to
target_fetch_registers.
* remote.c (remote_fetch_registers): Add ptid parameter and use
it.
* remote-sim.c (gdbsim_fetch_register): Likewise.
* rs6000-nat.c (fetch_register,
rs6000_fetch_inferior_registers): Likewise.
* s390-linux-nat.c (s390_linux_fetch_inferior_registers):
Likewise.
* sh-nbsd-nat.c (shnbsd_fetch_inferior_registers): Likewise.
* sol-thread.c (sol_thread_fetch_registers): Likewise.
* sparc-nat.c (sparc_fetch_inferior_registers): Likewise.
* sparc-nat.h (sparc_fetch_inferior_registers): Likewise.
* sparc-ravenscar-thread.c (sparc_ravenscar_fetch_registers):
Add ptid parameter and use it.  Remove declaration at top of
file.
* spu-multiarch.c (spu_fetch_registers): Add ptid parameter and
use it.
* tilegx-linux-nat.c (fetch_inferior_registers): Likewise.
* tracefile-tfile.c (tfile_fetch_registers): Likewise.
* vax-bsd-nat.c (vaxbsd_fetch_inferior_registers): Likewise.
* windows-nat.c (windows_fetch_inferior_registers): Likewise.
* xtensa-linux-nat.c (fetch_gregs, fetch_xtregs,
xtensa_linux_fetch_inferior_registers): Likewise.

63 files changed:
gdb/aarch64-linux-nat.c
gdb/aix-thread.c
gdb/alpha-bsd-nat.c
gdb/amd64-bsd-nat.c
gdb/amd64-linux-nat.c
gdb/arm-linux-nat.c
gdb/arm-nbsd-nat.c
gdb/bsd-kvm.c
gdb/bsd-uthread.c
gdb/corelow.c
gdb/ctf.c
gdb/fbsd-tdep.c
gdb/go32-nat.c
gdb/hppa-linux-nat.c
gdb/hppa-nbsd-nat.c
gdb/hppa-obsd-nat.c
gdb/i386-bsd-nat.c
gdb/i386-darwin-nat.c
gdb/i386-gnu-nat.c
gdb/i386-linux-nat.c
gdb/ia64-linux-nat.c
gdb/inf-child.c
gdb/inf-ptrace.c
gdb/linux-tdep.c
gdb/m32r-linux-nat.c
gdb/m68k-bsd-nat.c
gdb/m68k-linux-nat.c
gdb/m88k-bsd-nat.c
gdb/mips-fbsd-nat.c
gdb/mips-linux-nat.c
gdb/mips-nbsd-nat.c
gdb/mips64-obsd-nat.c
gdb/nto-procfs.c
gdb/ppc-fbsd-nat.c
gdb/ppc-linux-nat.c
gdb/ppc-nbsd-nat.c
gdb/ppc-obsd-nat.c
gdb/ppc-ravenscar-thread.c
gdb/proc-service.c
gdb/procfs.c
gdb/ravenscar-thread.c
gdb/ravenscar-thread.h
gdb/record-btrace.c
gdb/record-full.c
gdb/regcache.c
gdb/remote-sim.c
gdb/remote.c
gdb/rs6000-nat.c
gdb/s390-linux-nat.c
gdb/sh-nbsd-nat.c
gdb/sol-thread.c
gdb/sparc-nat.c
gdb/sparc-nat.h
gdb/sparc-ravenscar-thread.c
gdb/spu-multiarch.c
gdb/target-delegates.c
gdb/target.c
gdb/target.h
gdb/tilegx-linux-nat.c
gdb/tracefile-tfile.c
gdb/vax-bsd-nat.c
gdb/windows-nat.c
gdb/xtensa-linux-nat.c

index 0d472e2e53a31a6ac8dcd16374e206a2b7eca65d..3fc340496ccaa08f67e91571ae53494074da6cd7 100644 (file)
@@ -152,7 +152,7 @@ aarch64_get_debug_reg_state (pid_t pid)
    from the current thread.  */
 
 static void
-fetch_gregs_from_thread (struct regcache *regcache)
+fetch_gregs_from_thread (struct regcache *regcache, ptid_t ptid)
 {
   int ret, tid;
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
@@ -163,7 +163,7 @@ fetch_gregs_from_thread (struct regcache *regcache)
      and arm.  */
   gdb_static_assert (sizeof (regs) >= 18 * 4);
 
-  tid = ptid_get_lwp (inferior_ptid);
+  tid = ptid_get_lwp (ptid);
 
   iovec.iov_base = &regs;
   if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
@@ -233,7 +233,7 @@ store_gregs_to_thread (const struct regcache *regcache)
    from the current thread.  */
 
 static void
-fetch_fpregs_from_thread (struct regcache *regcache)
+fetch_fpregs_from_thread (struct regcache *regcache, ptid_t ptid)
 {
   int ret, tid;
   elf_fpregset_t regs;
@@ -244,7 +244,7 @@ fetch_fpregs_from_thread (struct regcache *regcache)
      and arm.  */
   gdb_static_assert (sizeof regs >= VFP_REGS_SIZE);
 
-  tid = ptid_get_lwp (inferior_ptid);
+  tid = ptid_get_lwp (ptid);
 
   iovec.iov_base = &regs;
 
@@ -347,17 +347,17 @@ store_fpregs_to_thread (const struct regcache *regcache)
 static void
 aarch64_linux_fetch_inferior_registers (struct target_ops *ops,
                                        struct regcache *regcache,
-                                       int regno)
+                                       ptid_t ptid, int regno)
 {
   if (regno == -1)
     {
-      fetch_gregs_from_thread (regcache);
-      fetch_fpregs_from_thread (regcache);
+      fetch_gregs_from_thread (regcache, ptid);
+      fetch_fpregs_from_thread (regcache, ptid);
     }
   else if (regno < AARCH64_V0_REGNUM)
-    fetch_gregs_from_thread (regcache);
+    fetch_gregs_from_thread (regcache, ptid);
   else
-    fetch_fpregs_from_thread (regcache);
+    fetch_fpregs_from_thread (regcache, ptid);
 }
 
 /* Implement the "to_store_register" target_ops method.  */
index cf1a46221655b3fb15fc9c1066e38d66156549eb..b85c147f038e7f1edda16512108fb5a8fcaf748a 100644 (file)
@@ -1298,21 +1298,22 @@ fetch_regs_kernel_thread (struct regcache *regcache, int regno,
 }
 
 /* Fetch register REGNO if != -1 or all registers otherwise in the
-   thread/process specified by inferior_ptid.  */
+   thread/process specified by PTID.  */
 
 static void
 aix_thread_fetch_registers (struct target_ops *ops,
-                            struct regcache *regcache, int regno)
+                            struct regcache *regcache,
+                           ptid_t ptid, int regno)
 {
   struct thread_info *thread;
   pthdb_tid_t tid;
   struct target_ops *beneath = find_target_beneath (ops);
 
-  if (!PD_TID (inferior_ptid))
-    beneath->to_fetch_registers (beneath, regcache, regno);
+  if (!PD_TID (ptid))
+    beneath->to_fetch_registers (beneath, regcache, ptid, regno);
   else
     {
-      thread = find_thread_ptid (inferior_ptid);
+      thread = find_thread_ptid (ptid);
       tid = thread->priv->tid;
 
       if (tid == PTHDB_INVALID_TID)
@@ -1652,7 +1653,7 @@ store_regs_kernel_thread (const struct regcache *regcache, int regno,
 }
 
 /* Store gdb's current view of the register set into the
-   thread/process specified by inferior_ptid.  */
+   thread/process specified by PTID.  */
 
 static void
 aix_thread_store_registers (struct target_ops *ops,
index 5914d89882ebbe9352b197a4569205482e2d2607..4440b5539be794156d07e5fcd06690bc279618db 100644 (file)
@@ -85,13 +85,14 @@ getregs_supplies (int regno)
 
 static void
 alphabsd_fetch_inferior_registers (struct target_ops *ops,
-                                  struct regcache *regcache, int regno)
+                                  struct regcache *regcache,
+                                  ptid_t ptid, int regno)
 {
   if (regno == -1 || getregs_supplies (regno))
     {
       struct reg gregs;
 
-      if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_GETREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &gregs, 0) == -1)
        perror_with_name (_("Couldn't get registers"));
 
@@ -105,7 +106,7 @@ alphabsd_fetch_inferior_registers (struct target_ops *ops,
     {
       struct fpreg fpregs;
 
-      if (ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_GETFPREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't get floating point status"));
 
@@ -118,18 +119,19 @@ alphabsd_fetch_inferior_registers (struct target_ops *ops,
 
 static void
 alphabsd_store_inferior_registers (struct target_ops *ops,
-                                  struct regcache *regcache, int regno)
+                                  struct regcache *regcache,
+                                  ptid_t ptid, int regno)
 {
   if (regno == -1 || getregs_supplies (regno))
     {
       struct reg gregs;
-      if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_GETREGS, ptid_get_pid (ptid),
                   (PTRACE_TYPE_ARG3) &gregs, 0) == -1)
         perror_with_name (_("Couldn't get registers"));
 
       alphabsd_fill_reg (regcache, (char *) &gregs, regno);
 
-      if (ptrace (PT_SETREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_SETREGS, ptid_get_pid (ptid),
                   (PTRACE_TYPE_ARG3) &gregs, 0) == -1)
         perror_with_name (_("Couldn't write registers"));
 
@@ -142,13 +144,13 @@ alphabsd_store_inferior_registers (struct target_ops *ops,
     {
       struct fpreg fpregs;
 
-      if (ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_GETFPREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't get floating point status"));
 
       alphabsd_fill_fpreg (regcache, (char *) &fpregs, regno);
 
-      if (ptrace (PT_SETFPREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_SETFPREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't write floating point status"));
     }
index 5678e94d11237a290680912635e20d8f328d56de..1fd0e296106c64cb390304c0b32608ee0ffaad28 100644 (file)
@@ -40,7 +40,8 @@
 
 static void
 amd64bsd_fetch_inferior_registers (struct target_ops *ops,
-                                  struct regcache *regcache, int regnum)
+                                  struct regcache *regcache,
+                                  ptid_t ptid, int regnum)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 
@@ -48,7 +49,7 @@ amd64bsd_fetch_inferior_registers (struct target_ops *ops,
     {
       struct reg regs;
 
-      if (ptrace (PT_GETREGS, get_ptrace_pid (inferior_ptid),
+      if (ptrace (PT_GETREGS, get_ptrace_pid (ptid),
                  (PTRACE_TYPE_ARG3) &regs, 0) == -1)
        perror_with_name (_("Couldn't get registers"));
 
@@ -66,7 +67,7 @@ amd64bsd_fetch_inferior_registers (struct target_ops *ops,
       if (x86bsd_xsave_len != 0)
        {
          xstateregs = alloca (x86bsd_xsave_len);
-         if (ptrace (PT_GETXSTATE, get_ptrace_pid (inferior_ptid),
+         if (ptrace (PT_GETXSTATE, get_ptrace_pid (ptid),
                      (PTRACE_TYPE_ARG3) xstateregs, 0) == -1)
            perror_with_name (_("Couldn't get extended state status"));
 
@@ -75,7 +76,7 @@ amd64bsd_fetch_inferior_registers (struct target_ops *ops,
        }
 #endif
 
-      if (ptrace (PT_GETFPREGS, get_ptrace_pid (inferior_ptid),
+      if (ptrace (PT_GETFPREGS, get_ptrace_pid (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't get floating point status"));
 
@@ -88,7 +89,8 @@ amd64bsd_fetch_inferior_registers (struct target_ops *ops,
 
 static void
 amd64bsd_store_inferior_registers (struct target_ops *ops,
-                                  struct regcache *regcache, int regnum)
+                                  struct regcache *regcache,
+                                  ptid_t ptid, int regnum)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 
@@ -96,13 +98,13 @@ amd64bsd_store_inferior_registers (struct target_ops *ops,
     {
       struct reg regs;
 
-      if (ptrace (PT_GETREGS, get_ptrace_pid (inferior_ptid),
+      if (ptrace (PT_GETREGS, get_ptrace_pid (ptid),
                   (PTRACE_TYPE_ARG3) &regs, 0) == -1)
         perror_with_name (_("Couldn't get registers"));
 
       amd64_collect_native_gregset (regcache, &regs, regnum);
 
-      if (ptrace (PT_SETREGS, get_ptrace_pid (inferior_ptid),
+      if (ptrace (PT_SETREGS, get_ptrace_pid (ptid),
                  (PTRACE_TYPE_ARG3) &regs, 0) == -1)
         perror_with_name (_("Couldn't write registers"));
 
@@ -119,26 +121,26 @@ amd64bsd_store_inferior_registers (struct target_ops *ops,
       if (x86bsd_xsave_len != 0)
        {
          xstateregs = alloca (x86bsd_xsave_len);
-         if (ptrace (PT_GETXSTATE, get_ptrace_pid (inferior_ptid),
+         if (ptrace (PT_GETXSTATE, get_ptrace_pid (ptid),
                      (PTRACE_TYPE_ARG3) xstateregs, 0) == -1)
            perror_with_name (_("Couldn't get extended state status"));
 
          amd64_collect_xsave (regcache, regnum, xstateregs, 0);
 
-         if (ptrace (PT_SETXSTATE, get_ptrace_pid (inferior_ptid),
+         if (ptrace (PT_SETXSTATE, get_ptrace_pid (ptid),
                      (PTRACE_TYPE_ARG3) xstateregs, x86bsd_xsave_len) == -1)
            perror_with_name (_("Couldn't write extended state status"));
          return;
        }
 #endif
 
-      if (ptrace (PT_GETFPREGS, get_ptrace_pid (inferior_ptid),
+      if (ptrace (PT_GETFPREGS, get_ptrace_pid (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't get floating point status"));
 
       amd64_collect_fxsave (regcache, regnum, &fpregs);
 
-      if (ptrace (PT_SETFPREGS, get_ptrace_pid (inferior_ptid),
+      if (ptrace (PT_SETFPREGS, get_ptrace_pid (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't write floating point status"));
     }
index 4a429ec2a16444f1fe37b55e9172d028c294fbd1..a9f61cddaca74296fe9dac85ce33224b9a3b4564 100644 (file)
@@ -132,15 +132,16 @@ fill_fpregset (const struct regcache *regcache,
 
 static void
 amd64_linux_fetch_inferior_registers (struct target_ops *ops,
-                                     struct regcache *regcache, int regnum)
+                                     struct regcache *regcache,
+                                     ptid_t ptid, int regnum)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int tid;
 
   /* GNU/Linux LWP ID's are process ID's.  */
-  tid = ptid_get_lwp (inferior_ptid);
+  tid = ptid_get_lwp (ptid);
   if (tid == 0)
-    tid = ptid_get_pid (inferior_ptid); /* Not a threaded program.  */
+    tid = ptid_get_pid (ptid); /* Not a threaded program.  */
 
   if (regnum == -1 || amd64_native_gregset_supplies_p (gdbarch, regnum))
     {
index c8474a9f4f6c3f017ba805d7347c7573a3800330..86ac33d307257e1832a9766ffdaf001a2651cf1a 100644 (file)
@@ -70,13 +70,13 @@ extern int arm_apcs_32;
    into regcache.  */
 
 static void
-fetch_fpregs (struct regcache *regcache)
+fetch_fpregs (struct regcache *regcache, ptid_t ptid)
 {
   int ret, regno, tid;
   gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
 
   /* Get the thread id for the ptrace call.  */
-  tid = ptid_get_lwp (inferior_ptid);
+  tid = ptid_get_lwp (ptid);
 
   /* Read the floating point state.  */
   if (have_ptrace_getregset == TRIBOOL_TRUE)
@@ -161,13 +161,13 @@ store_fpregs (const struct regcache *regcache)
    regcache.  */
 
 static void
-fetch_regs (struct regcache *regcache)
+fetch_regs (struct regcache *regcache, ptid_t ptid)
 {
   int ret, regno, tid;
   elf_gregset_t regs;
 
   /* Get the thread id for the ptrace call.  */
-  tid = ptid_get_lwp (inferior_ptid);
+  tid = ptid_get_lwp (ptid);
 
   if (have_ptrace_getregset == TRIBOOL_TRUE)
     {
@@ -236,13 +236,13 @@ store_regs (const struct regcache *regcache)
 #define IWMMXT_REGS_SIZE (16 * 8 + 6 * 4)
 
 static void
-fetch_wmmx_regs (struct regcache *regcache)
+fetch_wmmx_regs (struct regcache *regcache, ptid_t ptid)
 {
   char regbuf[IWMMXT_REGS_SIZE];
   int ret, regno, tid;
 
   /* Get the thread id for the ptrace call.  */
-  tid = ptid_get_lwp (inferior_ptid);
+  tid = ptid_get_lwp (ptid);
 
   ret = ptrace (PTRACE_GETWMMXREGS, tid, 0, regbuf);
   if (ret < 0)
@@ -299,7 +299,7 @@ store_wmmx_regs (const struct regcache *regcache)
 }
 
 static void
-fetch_vfp_regs (struct regcache *regcache)
+fetch_vfp_regs (struct regcache *regcache, ptid_t ptid)
 {
   gdb_byte regbuf[VFP_REGS_SIZE];
   int ret, regno, tid;
@@ -307,7 +307,7 @@ fetch_vfp_regs (struct regcache *regcache)
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
   /* Get the thread id for the ptrace call.  */
-  tid = ptid_get_lwp (inferior_ptid);
+  tid = ptid_get_lwp (ptid);
 
   if (have_ptrace_getregset == TRIBOOL_TRUE)
     {
@@ -376,34 +376,35 @@ store_vfp_regs (const struct regcache *regcache)
 
 static void
 arm_linux_fetch_inferior_registers (struct target_ops *ops,
-                                   struct regcache *regcache, int regno)
+                                   struct regcache *regcache,
+                                   ptid_t ptid, int regno)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
   if (-1 == regno)
     {
-      fetch_regs (regcache);
+      fetch_regs (regcache, ptid);
       if (tdep->have_wmmx_registers)
-       fetch_wmmx_regs (regcache);
+       fetch_wmmx_regs (regcache, ptid);
       if (tdep->vfp_register_count > 0)
-       fetch_vfp_regs (regcache);
+       fetch_vfp_regs (regcache, ptid);
       if (tdep->have_fpa_registers)
-       fetch_fpregs (regcache);
+       fetch_fpregs (regcache, ptid);
     }
   else
     {
       if (regno < ARM_F0_REGNUM || regno == ARM_PS_REGNUM)
-       fetch_regs (regcache);
+       fetch_regs (regcache, ptid);
       else if (regno >= ARM_F0_REGNUM && regno <= ARM_FPS_REGNUM)
-       fetch_fpregs (regcache);
+       fetch_fpregs (regcache, ptid);
       else if (tdep->have_wmmx_registers
               && regno >= ARM_WR0_REGNUM && regno <= ARM_WCGR7_REGNUM)
-       fetch_wmmx_regs (regcache);
+       fetch_wmmx_regs (regcache, ptid);
       else if (tdep->vfp_register_count > 0
               && regno >= ARM_D0_REGNUM
               && regno <= ARM_D0_REGNUM + tdep->vfp_register_count)
-       fetch_vfp_regs (regcache);
+       fetch_vfp_regs (regcache, ptid);
     }
 }
 
index 95bb1b2ad097876665ad21ed7376eec2259c3ab2..8857e37ce0199f66edb475b875afffea43879db5 100644 (file)
@@ -72,12 +72,12 @@ arm_supply_fparegset (struct regcache *regcache, struct fpreg *fparegset)
 }
 
 static void
-fetch_register (struct regcache *regcache, int regno)
+fetch_register (struct regcache *regcache, ptid_t ptid, int regno)
 {
   struct reg inferior_registers;
   int ret;
 
-  ret = ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+  ret = ptrace (PT_GETREGS, ptid_get_pid (ptid),
                (PTRACE_TYPE_ARG3) &inferior_registers, 0);
 
   if (ret < 0)
@@ -124,13 +124,13 @@ fetch_register (struct regcache *regcache, int regno)
 }
 
 static void
-fetch_regs (struct regcache *regcache)
+fetch_regs (struct regcache *regcache, ptid_t ptid)
 {
   struct reg inferior_registers;
   int ret;
   int regno;
 
-  ret = ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+  ret = ptrace (PT_GETREGS, ptid_get_pid (ptid),
                (PTRACE_TYPE_ARG3) &inferior_registers, 0);
 
   if (ret < 0)
@@ -143,12 +143,12 @@ fetch_regs (struct regcache *regcache)
 }
 
 static void
-fetch_fp_register (struct regcache *regcache, int regno)
+fetch_fp_register (struct regcache *regcache, ptid_t ptid, int regno)
 {
   struct fpreg inferior_fp_registers;
   int ret;
 
-  ret = ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),
+  ret = ptrace (PT_GETFPREGS, ptid_get_pid (ptid),
                (PTRACE_TYPE_ARG3) &inferior_fp_registers, 0);
 
   if (ret < 0)
@@ -172,13 +172,13 @@ fetch_fp_register (struct regcache *regcache, int regno)
 }
 
 static void
-fetch_fp_regs (struct regcache *regcache)
+fetch_fp_regs (struct regcache *regcache, ptid_t ptid)
 {
   struct fpreg inferior_fp_registers;
   int ret;
   int regno;
 
-  ret = ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),
+  ret = ptrace (PT_GETFPREGS, ptid_get_pid (ptid),
                (PTRACE_TYPE_ARG3) &inferior_fp_registers, 0);
 
   if (ret < 0)
@@ -192,19 +192,20 @@ fetch_fp_regs (struct regcache *regcache)
 
 static void
 armnbsd_fetch_registers (struct target_ops *ops,
-                        struct regcache *regcache, int regno)
+                        struct regcache *regcache,
+                        ptid_t ptid, int regno)
 {
   if (regno >= 0)
     {
       if (regno < ARM_F0_REGNUM || regno > ARM_FPS_REGNUM)
-       fetch_register (regcache, regno);
+       fetch_register (regcache, ptid, regno);
       else
-       fetch_fp_register (regcache, regno);
+       fetch_fp_register (regcache, ptid, regno);
     }
   else
     {
-      fetch_regs (regcache);
-      fetch_fp_regs (regcache);
+      fetch_regs (regcache, ptid);
+      fetch_fp_regs (regcache, ptid);
     }
 }
 
index 9f4f9e71edf94127c5da7213da40feec367d556a..7ca59ba2b993b3989fded6f34f7be9a61325298c 100644 (file)
@@ -185,7 +185,8 @@ bsd_kvm_fetch_pcb (struct regcache *regcache, struct pcb *paddr)
 
 static void
 bsd_kvm_fetch_registers (struct target_ops *ops,
-                        struct regcache *regcache, int regnum)
+                        struct regcache *regcache,
+                        ptid_t ptid, int regnum)
 {
   struct nlist nl[2];
 
index 2111128f21969f54bb494d3ac407e221b77b491d..c2c9866cd03ba2a5e0b326f76a4e5019f74f6634 100644 (file)
@@ -280,19 +280,18 @@ bsd_uthread_mourn_inferior (struct target_ops *ops)
 }
 
 static void
-bsd_uthread_fetch_registers (struct target_ops *ops,
-                            struct regcache *regcache, int regnum)
+bsd_uthread_fetch_registers (struct target_ops *ops, struct regcache *regcache,
+                            ptid_t ptid, int regnum)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   struct bsd_uthread_ops *uthread_ops
     = (struct bsd_uthread_ops *) gdbarch_data (gdbarch, bsd_uthread_data);
-  ptid_t ptid = inferior_ptid;
   CORE_ADDR addr = ptid_get_tid (ptid);
   struct target_ops *beneath = find_target_beneath (ops);
   CORE_ADDR active_addr;
 
   /* Always fetch the appropriate registers from the layer beneath.  */
-  beneath->to_fetch_registers (beneath, regcache, regnum);
+  beneath->to_fetch_registers (beneath, regcache, ptid, regnum);
 
   /* FIXME: That might have gotten us more than we asked for.  Make
      sure we overwrite all relevant registers with values from the
index ecde9542b55516fffadfdd69d43e3dda6b9bbdd2..735ce9f7805c53791506589eb4039afadf44207e 100644 (file)
@@ -451,7 +451,7 @@ core_open (const char *arg, int from_tty)
     }
 
   /* Fetch all registers from core file.  */
-  target_fetch_registers (get_current_regcache (), -1);
+  target_fetch_registers (get_current_regcache (), inferior_ptid, -1);
 
   /* Now, set up the frame cache, and print the top of stack.  */
   reinit_frame_cache ();
@@ -605,8 +605,8 @@ get_core_registers_cb (const char *sect_name, int size,
 /* We just get all the registers, so we don't use regno.  */
 
 static void
-get_core_registers (struct target_ops *ops,
-                   struct regcache *regcache, int regno)
+get_core_registers (struct target_ops *ops, struct regcache *regcache,
+                   ptid_t ptid, int regno)
 {
   int i;
   struct gdbarch *gdbarch;
index 8716cadf97e6bce2512d651d29600319bc386121..4073d8b30d09204dfb98866bea683afcf5388408 100644 (file)
--- a/gdb/ctf.c
+++ b/gdb/ctf.c
@@ -1190,7 +1190,8 @@ ctf_files_info (struct target_ops *t)
 
 static void
 ctf_fetch_registers (struct target_ops *ops,
-                    struct regcache *regcache, int regno)
+                    struct regcache *regcache,
+                    ptid_t ptid, int regno)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   struct bt_ctf_event *event = NULL;
index e7579100234b1e0c50e88ace1e209c9ee67e3c62..e6f564e4f0fca9dd43c020eb709b1b590f9a86be 100644 (file)
@@ -193,15 +193,11 @@ static void
 fbsd_corefile_thread (struct thread_info *info,
                      struct fbsd_corefile_thread_data *args)
 {
-  struct cleanup *old_chain;
   struct regcache *regcache;
 
   regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
 
-  old_chain = save_inferior_ptid ();
-  inferior_ptid = info->ptid;
-  target_fetch_registers (regcache, -1);
-  do_cleanups (old_chain);
+  target_fetch_registers (regcache, info->ptid, -1);
 
   args->note_data = fbsd_collect_thread_registers
     (regcache, info->ptid, args->obfd, args->note_data,
index 1fca8e2e53f83e236260e984dc803825bb60781c..cc5fc8f188976b64dd423306022d894f3c7fc438 100644 (file)
@@ -507,7 +507,8 @@ fetch_register (struct regcache *regcache, int regno)
 
 static void
 go32_fetch_registers (struct target_ops *ops,
-                     struct regcache *regcache, int regno)
+                     struct regcache *regcache,
+                     ptid_t ptid, int regno)
 {
   if (regno >= 0)
     fetch_register (regcache, regno);
@@ -538,7 +539,8 @@ store_register (const struct regcache *regcache, int regno)
 
 static void
 go32_store_registers (struct target_ops *ops,
-                     struct regcache *regcache, int regno)
+                     struct regcache *regcache,
+                     ptid_t ptid, int regno)
 {
   unsigned r;
 
index 17d9ced9e5c51535cdfb179500dcd6889828619c..da1f914dd9e5d4128402aabc7ef2258174bb3946 100644 (file)
@@ -210,7 +210,7 @@ static const int greg_map[] =
 /* Fetch one register.  */
 
 static void
-fetch_register (struct regcache *regcache, int regno)
+fetch_register (struct regcache *regcache, ptid_t ptid, int regno)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int tid;
@@ -223,9 +223,9 @@ fetch_register (struct regcache *regcache, int regno)
     }
 
   /* GNU/Linux LWP ID's are process ID's.  */
-  tid = ptid_get_lwp (inferior_ptid);
+  tid = ptid_get_lwp (ptid);
   if (tid == 0)
-    tid = ptid_get_pid (inferior_ptid); /* Not a threaded program.  */
+    tid = ptid_get_pid (ptid); /* Not a threaded program.  */
 
   errno = 0;
   val = ptrace (PTRACE_PEEKUSER, tid, hppa_linux_register_addr (regno, 0), 0);
@@ -269,18 +269,19 @@ store_register (const struct regcache *regcache, int regno)
 
 static void
 hppa_linux_fetch_inferior_registers (struct target_ops *ops,
-                                    struct regcache *regcache, int regno)
+                                    struct regcache *regcache,
+                                    ptid_t ptid, int regno)
 {
   if (-1 == regno)
     {
       for (regno = 0;
           regno < gdbarch_num_regs (get_regcache_arch (regcache));
           regno++)
-        fetch_register (regcache, regno);
+        fetch_register (regcache, ptid, regno);
     }
   else 
     {
-      fetch_register (regcache, regno);
+      fetch_register (regcache, ptid, regno);
     }
 }
 
index 200bc6881eaf9bf516e40591d4ca3d4e1af8e08e..caf71dac028e5eb3240f5c8c24bb64251261ec83 100644 (file)
@@ -160,14 +160,15 @@ hppanbsd_collect_fpregset (struct regcache *regcache,
 
 static void
 hppanbsd_fetch_registers (struct target_ops *ops,
-                         struct regcache *regcache, int regnum)
+                         struct regcache *regcache,
+                         ptid_t ptid, int regnum)
 
 {
   if (regnum == -1 || hppanbsd_gregset_supplies_p (regnum))
     {
       struct reg regs;
 
-      if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_GETREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &regs, 0) == -1)
        perror_with_name (_("Couldn't get registers"));
 
@@ -178,7 +179,7 @@ hppanbsd_fetch_registers (struct target_ops *ops,
     {
       struct fpreg fpregs;
 
-      if (ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_GETFPREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't get floating point status"));
 
@@ -191,19 +192,20 @@ hppanbsd_fetch_registers (struct target_ops *ops,
 
 static void
 hppanbsd_store_registers (struct target_ops *ops,
-                         struct regcache *regcache, int regnum)
+                         struct regcache *regcache,
+                         ptid_t ptid, int regnum)
 {
   if (regnum == -1 || hppanbsd_gregset_supplies_p (regnum))
     {
       struct reg regs;
 
-      if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_GETREGS, ptid_get_pid (ptid),
                   (PTRACE_TYPE_ARG3) &regs, 0) == -1)
         perror_with_name (_("Couldn't get registers"));
 
       hppanbsd_collect_gregset (regcache, &regs, regnum);
 
-      if (ptrace (PT_SETREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_SETREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &regs, 0) == -1)
         perror_with_name (_("Couldn't write registers"));
     }
@@ -212,13 +214,13 @@ hppanbsd_store_registers (struct target_ops *ops,
     {
       struct fpreg fpregs;
 
-      if (ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_GETFPREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't get floating point status"));
 
       hppanbsd_collect_fpregset (regcache, &fpregs, regnum);
 
-      if (ptrace (PT_SETFPREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_SETFPREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't write floating point status"));
     }
index 66af86b0f77574198cc6f073a28b4a3d5e2fd340..9be12d05e2667f0e8afd0032a3e555ab86b86a75 100644 (file)
@@ -187,13 +187,14 @@ hppaobsd_collect_fpregset (struct regcache *regcache,
 
 static void
 hppaobsd_fetch_registers (struct target_ops *ops,
-                         struct regcache *regcache, int regnum)
+                         struct regcache *regcache,
+                         ptid_t ptid, int regnum)
 {
   if (regnum == -1 || hppaobsd_gregset_supplies_p (regnum))
     {
       struct reg regs;
 
-      if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_GETREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &regs, 0) == -1)
        perror_with_name (_("Couldn't get registers"));
 
@@ -204,7 +205,7 @@ hppaobsd_fetch_registers (struct target_ops *ops,
     {
       struct fpreg fpregs;
 
-      if (ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_GETFPREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't get floating point status"));
 
@@ -217,19 +218,20 @@ hppaobsd_fetch_registers (struct target_ops *ops,
 
 static void
 hppaobsd_store_registers (struct target_ops *ops,
-                         struct regcache *regcache, int regnum)
+                         struct regcache *regcache,
+                         ptid_t ptid, int regnum)
 {
   if (regnum == -1 || hppaobsd_gregset_supplies_p (regnum))
     {
       struct reg regs;
 
-      if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_GETREGS, ptid_get_pid (ptid),
                   (PTRACE_TYPE_ARG3) &regs, 0) == -1)
         perror_with_name (_("Couldn't get registers"));
 
       hppaobsd_collect_gregset (regcache, &regs, regnum);
 
-      if (ptrace (PT_SETREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_SETREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &regs, 0) == -1)
         perror_with_name (_("Couldn't write registers"));
     }
@@ -238,13 +240,13 @@ hppaobsd_store_registers (struct target_ops *ops,
     {
       struct fpreg fpregs;
 
-      if (ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_GETFPREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't get floating point status"));
 
       hppaobsd_collect_fpregset (regcache, &fpregs, regnum);
 
-      if (ptrace (PT_SETFPREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_SETFPREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't write floating point status"));
     }
index 186856cc5f37b6ceaf68e1c8c57b174d2d4cb43a..8e5437c4ba576d1a01c9984b3dd212a022acd58d 100644 (file)
@@ -129,13 +129,14 @@ i386bsd_collect_gregset (const struct regcache *regcache,
 
 static void
 i386bsd_fetch_inferior_registers (struct target_ops *ops,
-                                 struct regcache *regcache, int regnum)
+                                 struct regcache *regcache,
+                                 ptid_t ptid, int regnum)
 {
   if (regnum == -1 || GETREGS_SUPPLIES (regnum))
     {
       struct reg regs;
 
-      if (ptrace (PT_GETREGS, get_ptrace_pid (inferior_ptid),
+      if (ptrace (PT_GETREGS, get_ptrace_pid (ptid),
                  (PTRACE_TYPE_ARG3) &regs, 0) == -1)
        perror_with_name (_("Couldn't get registers"));
 
@@ -157,7 +158,7 @@ i386bsd_fetch_inferior_registers (struct target_ops *ops,
          void *xstateregs;
 
          xstateregs = alloca (x86bsd_xsave_len);
-         if (ptrace (PT_GETXSTATE, get_ptrace_pid (inferior_ptid),
+         if (ptrace (PT_GETXSTATE, get_ptrace_pid (ptid),
                      (PTRACE_TYPE_ARG3) xstateregs, 0) == -1)
            perror_with_name (_("Couldn't get extended state status"));
 
@@ -168,7 +169,7 @@ i386bsd_fetch_inferior_registers (struct target_ops *ops,
       
 #ifdef HAVE_PT_GETXMMREGS
       if (have_ptrace_xmmregs != 0
-         && ptrace(PT_GETXMMREGS, get_ptrace_pid (inferior_ptid),
+         && ptrace(PT_GETXMMREGS, get_ptrace_pid (ptid),
                    (PTRACE_TYPE_ARG3) xmmregs, 0) == 0)
        {
          have_ptrace_xmmregs = 1;
@@ -178,7 +179,7 @@ i386bsd_fetch_inferior_registers (struct target_ops *ops,
        {
          have_ptrace_xmmregs = 0;
 #endif
-          if (ptrace (PT_GETFPREGS, get_ptrace_pid (inferior_ptid),
+          if (ptrace (PT_GETFPREGS, get_ptrace_pid (ptid),
                      (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
            perror_with_name (_("Couldn't get floating point status"));
 
@@ -194,19 +195,20 @@ i386bsd_fetch_inferior_registers (struct target_ops *ops,
 
 static void
 i386bsd_store_inferior_registers (struct target_ops *ops,
-                                 struct regcache *regcache, int regnum)
+                                 struct regcache *regcache,
+                                 ptid_t ptid, int regnum)
 {
   if (regnum == -1 || GETREGS_SUPPLIES (regnum))
     {
       struct reg regs;
 
-      if (ptrace (PT_GETREGS, get_ptrace_pid (inferior_ptid),
+      if (ptrace (PT_GETREGS, get_ptrace_pid (ptid),
                   (PTRACE_TYPE_ARG3) &regs, 0) == -1)
         perror_with_name (_("Couldn't get registers"));
 
       i386bsd_collect_gregset (regcache, &regs, regnum);
 
-      if (ptrace (PT_SETREGS, get_ptrace_pid (inferior_ptid),
+      if (ptrace (PT_SETREGS, get_ptrace_pid (ptid),
                  (PTRACE_TYPE_ARG3) &regs, 0) == -1)
         perror_with_name (_("Couldn't write registers"));
 
@@ -227,13 +229,13 @@ i386bsd_store_inferior_registers (struct target_ops *ops,
          void *xstateregs;
 
          xstateregs = alloca (x86bsd_xsave_len);
-         if (ptrace (PT_GETXSTATE, get_ptrace_pid (inferior_ptid),
+         if (ptrace (PT_GETXSTATE, get_ptrace_pid (ptid),
                      (PTRACE_TYPE_ARG3) xstateregs, 0) == -1)
            perror_with_name (_("Couldn't get extended state status"));
 
          i387_collect_xsave (regcache, -1, xstateregs, 0);
 
-         if (ptrace (PT_SETXSTATE, get_ptrace_pid (inferior_ptid),
+         if (ptrace (PT_SETXSTATE, get_ptrace_pid (ptid),
                      (PTRACE_TYPE_ARG3) xstateregs, x86bsd_xsave_len) == -1)
            perror_with_name (_("Couldn't write extended state status"));
          return;
@@ -242,14 +244,14 @@ i386bsd_store_inferior_registers (struct target_ops *ops,
 
 #ifdef HAVE_PT_GETXMMREGS
       if (have_ptrace_xmmregs != 0
-         && ptrace(PT_GETXMMREGS, get_ptrace_pid (inferior_ptid),
+         && ptrace(PT_GETXMMREGS, get_ptrace_pid (ptid),
                    (PTRACE_TYPE_ARG3) xmmregs, 0) == 0)
        {
          have_ptrace_xmmregs = 1;
 
          i387_collect_fxsave (regcache, regnum, xmmregs);
 
-         if (ptrace (PT_SETXMMREGS, get_ptrace_pid (inferior_ptid),
+         if (ptrace (PT_SETXMMREGS, get_ptrace_pid (ptid),
                      (PTRACE_TYPE_ARG3) xmmregs, 0) == -1)
             perror_with_name (_("Couldn't write XMM registers"));
        }
@@ -257,13 +259,13 @@ i386bsd_store_inferior_registers (struct target_ops *ops,
        {
          have_ptrace_xmmregs = 0;
 #endif
-          if (ptrace (PT_GETFPREGS, get_ptrace_pid (inferior_ptid),
+          if (ptrace (PT_GETFPREGS, get_ptrace_pid (ptid),
                      (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
            perror_with_name (_("Couldn't get floating point status"));
 
           i387_collect_fsave (regcache, regnum, &fpregs);
 
-          if (ptrace (PT_SETFPREGS, get_ptrace_pid (inferior_ptid),
+          if (ptrace (PT_SETFPREGS, get_ptrace_pid (ptid),
                      (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
            perror_with_name (_("Couldn't write floating point status"));
 #ifdef HAVE_PT_GETXMMREGS
index 4bffe6d74e35a22a85029e415a2e9a2e348e7fcb..9cabc3f111623e8391a3bf135bd6463718f88462 100644 (file)
    Otherwise, REGNO specifies which register (so we can save time).  */
 static void
 i386_darwin_fetch_inferior_registers (struct target_ops *ops,
-                                     struct regcache *regcache, int regno)
+                                     struct regcache *regcache,
+                                     ptid_t ptid, int regno)
 {
-  thread_t current_thread = ptid_get_tid (inferior_ptid);
+  thread_t current_thread = ptid_get_tid (ptid);
   int fetched = 0;
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 
@@ -165,9 +166,10 @@ i386_darwin_fetch_inferior_registers (struct target_ops *ops,
 
 static void
 i386_darwin_store_inferior_registers (struct target_ops *ops,
-                                     struct regcache *regcache, int regno)
+                                     struct regcache *regcache,
+                                     ptid_t ptid, int regno)
 {
-  thread_t current_thread = ptid_get_tid (inferior_ptid);
+  thread_t current_thread = ptid_get_tid (ptid);
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 
 #ifdef BFD64
index 6953eeb78e1bc973337cc8d54a50a2c1424d7b0e..fe47934e974f59de58592e208e86076aeacde3d5 100644 (file)
@@ -88,7 +88,8 @@ fetch_fpregs (struct regcache *regcache, struct proc *thread)
 /* Fetch register REGNO, or all regs if REGNO is -1.  */
 static void
 gnu_fetch_registers (struct target_ops *ops,
-                    struct regcache *regcache, int regno)
+                    struct regcache *regcache,
+                    ptid_t ptid, int regno)
 {
   struct proc *thread;
 
@@ -96,10 +97,10 @@ gnu_fetch_registers (struct target_ops *ops,
   inf_update_procs (gnu_current_inf);
 
   thread = inf_tid_to_thread (gnu_current_inf,
-                             ptid_get_lwp (inferior_ptid));
+                             ptid_get_lwp (ptid));
   if (!thread)
     error (_("Can't fetch registers from thread %s: No such thread"),
-          target_pid_to_str (inferior_ptid));
+          target_pid_to_str (ptid));
 
   if (regno < I386_NUM_GREGS || regno == -1)
     {
@@ -180,7 +181,8 @@ store_fpregs (const struct regcache *regcache, struct proc *thread, int regno)
 /* Store at least register REGNO, or all regs if REGNO == -1.  */
 static void
 gnu_store_registers (struct target_ops *ops,
-                    struct regcache *regcache, int regno)
+                    struct regcache *regcache,
+                    ptid_t ptid, int regno)
 {
   struct proc *thread;
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
@@ -189,10 +191,10 @@ gnu_store_registers (struct target_ops *ops,
   inf_update_procs (gnu_current_inf);
 
   thread = inf_tid_to_thread (gnu_current_inf,
-                             ptid_get_lwp (inferior_ptid));
+                             ptid_get_lwp (ptid));
   if (!thread)
     error (_("Couldn't store registers into thread %s: No such thread"),
-          target_pid_to_str (inferior_ptid));
+          target_pid_to_str (ptid));
 
   if (regno < I386_NUM_GREGS || regno == -1)
     {
index 2c4963b5f40e8786343cfff4b6b9f234dd209667..7602f8052924829e6e46f15b9009c590ba2446c2 100644 (file)
@@ -92,7 +92,7 @@ int have_ptrace_getfpxregs =
 /* Fetch one register.  */
 
 static void
-fetch_register (struct regcache *regcache, int regno)
+fetch_register (struct regcache *regcache, ptid_t ptid, int regno)
 {
   int tid;
   int val;
@@ -105,9 +105,9 @@ fetch_register (struct regcache *regcache, int regno)
     }
 
   /* GNU/Linux LWP ID's are process ID's.  */
-  tid = ptid_get_lwp (inferior_ptid);
+  tid = ptid_get_lwp (ptid);
   if (tid == 0)
-    tid = ptid_get_pid (inferior_ptid); /* Not a threaded program.  */
+    tid = ptid_get_pid (ptid); /* Not a threaded program.  */
 
   errno = 0;
   val = ptrace (PTRACE_PEEKUSER, tid,
@@ -453,7 +453,8 @@ store_fpxregs (const struct regcache *regcache, int tid, int regno)
 
 static void
 i386_linux_fetch_inferior_registers (struct target_ops *ops,
-                                    struct regcache *regcache, int regno)
+                                    struct regcache *regcache,
+                                    ptid_t ptid, int regno)
 {
   int tid;
 
@@ -465,15 +466,15 @@ i386_linux_fetch_inferior_registers (struct target_ops *ops,
 
       for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
        if (regno == -1 || regno == i)
-         fetch_register (regcache, i);
+         fetch_register (regcache, ptid, i);
 
       return;
     }
 
   /* GNU/Linux LWP ID's are process ID's.  */
-  tid = ptid_get_lwp (inferior_ptid);
+  tid = ptid_get_lwp (ptid);
   if (tid == 0)
-    tid = ptid_get_pid (inferior_ptid); /* Not a threaded program.  */
+    tid = ptid_get_pid (ptid); /* Not a threaded program.  */
 
   /* Use the PTRACE_GETFPXREGS request whenever possible, since it
      transfers more registers in one system call, and we'll cache the
@@ -486,7 +487,7 @@ i386_linux_fetch_inferior_registers (struct target_ops *ops,
       /* The call above might reset `have_ptrace_getregs'.  */
       if (!have_ptrace_getregs)
        {
-         i386_linux_fetch_inferior_registers (ops, regcache, regno);
+         i386_linux_fetch_inferior_registers (ops, regcache, ptid, regno);
          return;
        }
 
index e26dd1502506a631bc93e8ee06243ddc9c863809..da3fdaecf6932cc4c2606630152f45a0b6f594ab 100644 (file)
@@ -690,7 +690,7 @@ ia64_linux_can_use_hw_breakpoint (struct target_ops *self,
 /* Fetch register REGNUM from the inferior.  */
 
 static void
-ia64_linux_fetch_register (struct regcache *regcache, int regnum)
+ia64_linux_fetch_register (struct regcache *regcache, ptid_t ptid, int regnum)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   CORE_ADDR addr;
@@ -737,9 +737,9 @@ ia64_linux_fetch_register (struct regcache *regcache, int regnum)
 
   /* Cater for systems like GNU/Linux, that implement threads as
      separate processes.  */
-  pid = ptid_get_lwp (inferior_ptid);
+  pid = ptid_get_lwp (ptid);
   if (pid == 0)
-    pid = ptid_get_pid (inferior_ptid);
+    pid = ptid_get_pid (ptid);
 
   /* This isn't really an address, but ptrace thinks of it as one.  */
   addr = ia64_register_addr (gdbarch, regnum);
@@ -768,15 +768,16 @@ ia64_linux_fetch_register (struct regcache *regcache, int regnum)
 
 static void
 ia64_linux_fetch_registers (struct target_ops *ops,
-                           struct regcache *regcache, int regnum)
+                           struct regcache *regcache,
+                           ptid_t ptid, int regnum)
 {
   if (regnum == -1)
     for (regnum = 0;
         regnum < gdbarch_num_regs (get_regcache_arch (regcache));
         regnum++)
-      ia64_linux_fetch_register (regcache, regnum);
+      ia64_linux_fetch_register (regcache, ptid, regnum);
   else
-    ia64_linux_fetch_register (regcache, regnum);
+    ia64_linux_fetch_register (regcache, ptid, regnum);
 }
 
 /* Store register REGNUM into the inferior.  */
index b04b52e9b0ad2b4ba86464f2fbcbb7b426d99ef8..49445dd6888765f3f041627ef968f5d8eb73a2e8 100644 (file)
@@ -72,7 +72,8 @@ store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus)
 
 static void
 inf_child_fetch_inferior_registers (struct target_ops *ops,
-                                   struct regcache *regcache, int regnum)
+                                   struct regcache *regcache,
+                                   ptid_t ptid, int regnum)
 {
   if (regnum == -1)
     {
index 215787425f8818b42f089a4270a2b30e15b7ae86..3cc6a133fd968fa29f1aebc94cf48c6cf0affb5e 100644 (file)
@@ -706,7 +706,7 @@ static CORE_ADDR (*inf_ptrace_register_u_offset)(struct gdbarch *, int, int);
 /* Fetch register REGNUM from the inferior.  */
 
 static void
-inf_ptrace_fetch_register (struct regcache *regcache, int regnum)
+inf_ptrace_fetch_register (struct regcache *regcache, ptid_t ptid, int regnum)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   CORE_ADDR addr;
@@ -725,9 +725,9 @@ inf_ptrace_fetch_register (struct regcache *regcache, int regnum)
 
   /* Cater for systems like GNU/Linux, that implement threads as
      separate processes.  */
-  pid = ptid_get_lwp (inferior_ptid);
+  pid = ptid_get_lwp (ptid);
   if (pid == 0)
-    pid = ptid_get_pid (inferior_ptid);
+    pid = ptid_get_pid (ptid);
 
   size = register_size (gdbarch, regnum);
   gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
@@ -752,16 +752,16 @@ inf_ptrace_fetch_register (struct regcache *regcache, int regnum)
    for all registers.  */
 
 static void
-inf_ptrace_fetch_registers (struct target_ops *ops,
-                           struct regcache *regcache, int regnum)
+inf_ptrace_fetch_registers (struct target_ops *ops, struct regcache *regcache,
+                           ptid_t ptid, int regnum)
 {
   if (regnum == -1)
     for (regnum = 0;
         regnum < gdbarch_num_regs (get_regcache_arch (regcache));
         regnum++)
-      inf_ptrace_fetch_register (regcache, regnum);
+      inf_ptrace_fetch_register (regcache, ptid, regnum);
   else
-    inf_ptrace_fetch_register (regcache, regnum);
+    inf_ptrace_fetch_register (regcache, ptid, regnum);
 }
 
 /* Store register REGNUM into the inferior.  */
index 1a3e48d83d937b393efc98c821030272ec4b269d..e782e6955e043208b82fc6e1593784d9e02b079e 100644 (file)
@@ -1691,12 +1691,8 @@ linux_corefile_thread (struct thread_info *info,
   LONGEST siginfo_size = 0;
 
   regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
-
-  old_chain = save_inferior_ptid ();
-  inferior_ptid = info->ptid;
-  target_fetch_registers (regcache, -1);
+  target_fetch_registers (regcache, info->ptid, -1);
   siginfo_data = linux_get_siginfo_data (args->gdbarch, &siginfo_size);
-  do_cleanups (old_chain);
 
   old_chain = make_cleanup (xfree, siginfo_data);
 
index 9d9bef385ebf5fe7c8a01b132d65d68caa014813..ff47bf735febc3045a7ccf3c8c0ba75d11a26fed 100644 (file)
@@ -192,14 +192,15 @@ fill_fpregset (const struct regcache *regcache,
 
 static void
 m32r_linux_fetch_inferior_registers (struct target_ops *ops,
-                                    struct regcache *regcache, int regno)
+                                    struct regcache *regcache,
+                                    ptid_t ptid, int regno)
 {
   int tid;
 
   /* GNU/Linux LWP ID's are process ID's.  */
-  tid = ptid_get_lwp (inferior_ptid);
+  tid = ptid_get_lwp (ptid);
   if (tid == 0)
-    tid = ptid_get_pid (inferior_ptid);        /* Not a threaded program.  */
+    tid = ptid_get_pid (ptid); /* Not a threaded program.  */
 
   /* Use the PTRACE_GETREGS request whenever possible, since it
      transfers more registers in one system call, and we'll cache the
@@ -219,13 +220,14 @@ m32r_linux_fetch_inferior_registers (struct target_ops *ops,
    registers).  */
 static void
 m32r_linux_store_inferior_registers (struct target_ops *ops,
-                                    struct regcache *regcache, int regno)
+                                    struct regcache *regcache,
+                                    ptid_t ptid, int regno)
 {
   int tid;
 
   /* GNU/Linux LWP ID's are process ID's.  */
-  if ((tid = ptid_get_lwp (inferior_ptid)) == 0)
-    tid = ptid_get_pid (inferior_ptid);        /* Not a threaded program.  */
+  if ((tid = ptid_get_lwp (ptid)) == 0)
+    tid = ptid_get_pid (ptid); /* Not a threaded program.  */
 
   /* Use the PTRACE_SETREGS request whenever possible, since it
      transfers more registers in one system call.  */
index 227da382e63d892c7a3ec5f9b5dc2a708bceeadd..a4b745aae0a9838faad7a208b7eb90c61084422b 100644 (file)
@@ -109,13 +109,14 @@ m68kbsd_collect_fpregset (struct regcache *regcache,
 
 static void
 m68kbsd_fetch_inferior_registers (struct target_ops *ops,
-                                 struct regcache *regcache, int regnum)
+                                 struct regcache *regcache,
+                                 ptid_t ptid, int regnum)
 {
   if (regnum == -1 || m68kbsd_gregset_supplies_p (regnum))
     {
       struct reg regs;
 
-      if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_GETREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &regs, 0) == -1)
        perror_with_name (_("Couldn't get registers"));
 
@@ -126,7 +127,7 @@ m68kbsd_fetch_inferior_registers (struct target_ops *ops,
     {
       struct fpreg fpregs;
 
-      if (ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_GETFPREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't get floating point status"));
 
@@ -139,19 +140,20 @@ m68kbsd_fetch_inferior_registers (struct target_ops *ops,
 
 static void
 m68kbsd_store_inferior_registers (struct target_ops *ops,
-                                 struct regcache *regcache, int regnum)
+                                 struct regcache *regcache,
+                                 ptid_t ptid, int regnum)
 {
   if (regnum == -1 || m68kbsd_gregset_supplies_p (regnum))
     {
       struct reg regs;
 
-      if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_GETREGS, ptid_get_pid (ptid),
                   (PTRACE_TYPE_ARG3) &regs, 0) == -1)
         perror_with_name (_("Couldn't get registers"));
 
       m68kbsd_collect_gregset (regcache, &regs, regnum);
 
-      if (ptrace (PT_SETREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_SETREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &regs, 0) == -1)
         perror_with_name (_("Couldn't write registers"));
     }
@@ -160,13 +162,13 @@ m68kbsd_store_inferior_registers (struct target_ops *ops,
     {
       struct fpreg fpregs;
 
-      if (ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_GETFPREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't get floating point status"));
 
       m68kbsd_collect_fpregset (regcache, &fpregs, regnum);
 
-      if (ptrace (PT_SETFPREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_SETFPREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't write floating point status"));
     }
index e5182caf39197f759c85c2321e4d66c428f5911e..d7403e5e72aadbf373eef170738ecfd12bbb23fa 100644 (file)
@@ -100,7 +100,7 @@ static int have_ptrace_getregs =
 /* Fetch one register.  */
 
 static void
-fetch_register (struct regcache *regcache, int regno)
+fetch_register (struct regcache *regcache, ptid_t ptid, int regno)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   long regaddr, val;
@@ -109,9 +109,9 @@ fetch_register (struct regcache *regcache, int regno)
   int tid;
 
   /* Overload thread id onto process id.  */
-  tid = ptid_get_lwp (inferior_ptid);
+  tid = ptid_get_lwp (ptid);
   if (tid == 0)
-    tid = ptid_get_pid (inferior_ptid);        /* no thread id, just use
+    tid = ptid_get_pid (ptid); /* no thread id, just use
                                           process id.  */
 
   regaddr = 4 * regmap[regno];
@@ -134,11 +134,11 @@ fetch_register (struct regcache *regcache, int regno)
    Otherwise, REGNO specifies which register (so we can save time).  */
 
 static void
-old_fetch_inferior_registers (struct regcache *regcache, int regno)
+old_fetch_inferior_registers (struct regcache *regcache, ptid_t ptid, int regno)
 {
   if (regno >= 0)
     {
-      fetch_register (regcache, regno);
+      fetch_register (regcache, ptid, regno);
     }
   else
     {
@@ -146,7 +146,7 @@ old_fetch_inferior_registers (struct regcache *regcache, int regno)
           regno < gdbarch_num_regs (get_regcache_arch (regcache));
           regno++)
        {
-         fetch_register (regcache, regno);
+         fetch_register (regcache, ptid, regno);
        }
     }
 }
@@ -404,7 +404,8 @@ static void store_fpregs (const struct regcache *regcache, int tid, int regno)
 
 static void
 m68k_linux_fetch_inferior_registers (struct target_ops *ops,
-                                    struct regcache *regcache, int regno)
+                                    struct regcache *regcache,
+                                    ptid_t ptid, int regno)
 {
   int tid;
 
@@ -412,14 +413,14 @@ m68k_linux_fetch_inferior_registers (struct target_ops *ops,
      GETREGS request isn't available.  */
   if (! have_ptrace_getregs)
     {
-      old_fetch_inferior_registers (regcache, regno);
+      old_fetch_inferior_registers (regcache, ptid, regno);
       return;
     }
 
   /* GNU/Linux LWP ID's are process ID's.  */
-  tid = ptid_get_lwp (inferior_ptid);
+  tid = ptid_get_lwp (ptid);
   if (tid == 0)
-    tid = ptid_get_pid (inferior_ptid);        /* Not a threaded program.  */
+    tid = ptid_get_pid (ptid); /* Not a threaded program.  */
 
   /* Use the PTRACE_GETFPXREGS request whenever possible, since it
      transfers more registers in one system call, and we'll cache the
@@ -432,7 +433,7 @@ m68k_linux_fetch_inferior_registers (struct target_ops *ops,
       /* The call above might reset `have_ptrace_getregs'.  */
       if (! have_ptrace_getregs)
        {
-         old_fetch_inferior_registers (regcache, -1);
+         old_fetch_inferior_registers (regcache, ptid, -1);
          return;
        }
 
index 72d363071001290f2dd804c4d686c99674038fb7..895b6c85d318f12ea384a35bfe5123ec821ff3c8 100644 (file)
@@ -64,11 +64,12 @@ m88kbsd_collect_gregset (const struct regcache *regcache,
 
 static void
 m88kbsd_fetch_inferior_registers (struct target_ops *ops,
-                                 struct regcache *regcache, int regnum)
+                                 struct regcache *regcache,
+                                 ptid_t ptid, int regnum)
 {
   struct reg regs;
 
-  if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+  if (ptrace (PT_GETREGS, ptid_get_pid (ptid),
              (PTRACE_TYPE_ARG3) &regs, 0) == -1)
     perror_with_name (_("Couldn't get registers"));
 
@@ -80,17 +81,18 @@ m88kbsd_fetch_inferior_registers (struct target_ops *ops,
 
 static void
 m88kbsd_store_inferior_registers (struct target_ops *ops,
-                                 struct regcache *regcache, int regnum)
+                                 struct regcache *regcache,
+                                 ptid_t ptid, int regnum)
 {
   struct reg regs;
 
-  if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+  if (ptrace (PT_GETREGS, ptid_get_pid (ptid),
              (PTRACE_TYPE_ARG3) &regs, 0) == -1)
     perror_with_name (_("Couldn't get registers"));
 
   m88kbsd_collect_gregset (regcache, &regs, regnum);
 
-  if (ptrace (PT_SETREGS, ptid_get_pid (inferior_ptid),
+  if (ptrace (PT_SETREGS, ptid_get_pid (ptid),
              (PTRACE_TYPE_ARG3) &regs, 0) == -1)
     perror_with_name (_("Couldn't write registers"));
 }
index 0472df88f49545e789aafc10660683bbdce9f3a6..f8bce008c1cb2ed3b980c051cc762ac5fa40e16f 100644 (file)
@@ -45,14 +45,15 @@ getregs_supplies (struct gdbarch *gdbarch, int regnum)
 
 static void
 mips_fbsd_fetch_inferior_registers (struct target_ops *ops,
-                                   struct regcache *regcache, int regnum)
+                                   struct regcache *regcache,
+                                   ptid_t ptid, int regnum)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   if (regnum == -1 || getregs_supplies (gdbarch, regnum))
     {
       struct reg regs;
 
-      if (ptrace (PT_GETREGS, get_ptrace_pid (inferior_ptid),
+      if (ptrace (PT_GETREGS, get_ptrace_pid (ptid),
                  (PTRACE_TYPE_ARG3) &regs, 0) == -1)
        perror_with_name (_("Couldn't get registers"));
 
@@ -66,7 +67,7 @@ mips_fbsd_fetch_inferior_registers (struct target_ops *ops,
     {
       struct fpreg fpregs;
 
-      if (ptrace (PT_GETFPREGS, get_ptrace_pid (inferior_ptid),
+      if (ptrace (PT_GETFPREGS, get_ptrace_pid (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't get floating point status"));
 
@@ -80,21 +81,22 @@ mips_fbsd_fetch_inferior_registers (struct target_ops *ops,
 
 static void
 mips_fbsd_store_inferior_registers (struct target_ops *ops,
-                                   struct regcache *regcache, int regnum)
+                                   struct regcache *regcache,
+                                   ptid_t ptid, int regnum)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   if (regnum == -1 || getregs_supplies (gdbarch, regnum))
     {
       struct reg regs;
 
-      if (ptrace (PT_GETREGS, get_ptrace_pid (inferior_ptid),
+      if (ptrace (PT_GETREGS, get_ptrace_pid (ptid),
                  (PTRACE_TYPE_ARG3) &regs, 0) == -1)
        perror_with_name (_("Couldn't get registers"));
 
       mips_fbsd_collect_gregs (regcache, regnum, (char *) &regs,
                               sizeof (register_t));
 
-      if (ptrace (PT_SETREGS, get_ptrace_pid (inferior_ptid),
+      if (ptrace (PT_SETREGS, get_ptrace_pid (ptid),
                  (PTRACE_TYPE_ARG3) &regs, 0) == -1)
        perror_with_name (_("Couldn't write registers"));
 
@@ -107,14 +109,14 @@ mips_fbsd_store_inferior_registers (struct target_ops *ops,
     {
       struct fpreg fpregs;
 
-      if (ptrace (PT_GETFPREGS, get_ptrace_pid (inferior_ptid),
+      if (ptrace (PT_GETFPREGS, get_ptrace_pid (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't get floating point status"));
 
       mips_fbsd_collect_fpregs (regcache, regnum, (char *) &fpregs,
                                sizeof (f_register_t));
 
-      if (ptrace (PT_SETFPREGS, get_ptrace_pid (inferior_ptid),
+      if (ptrace (PT_SETFPREGS, get_ptrace_pid (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't write floating point status"));
     }
index 9d22773e9cff042948b391133f356e51e7778102..f9b6e1b2fc4c00a919a403a02af99d963d815077 100644 (file)
@@ -54,7 +54,7 @@ static int have_ptrace_regsets = 1;
    PTRACE_PEEKUSER and PTRACE_POKEUSER.  */
 
 static void (*super_fetch_registers) (struct target_ops *,
-                                     struct regcache *, int);
+                                     struct regcache *, ptid_t, int);
 static void (*super_store_registers) (struct target_ops *,
                                      struct regcache *, int);
 
@@ -214,7 +214,8 @@ fill_fpregset (const struct regcache *regcache,
 
 static void
 mips64_linux_regsets_fetch_registers (struct target_ops *ops,
-                                     struct regcache *regcache, int regno)
+                                     struct regcache *regcache,
+                                     ptid_t ptid, int regno)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int is_fp, is_dsp;
@@ -244,9 +245,9 @@ mips64_linux_regsets_fetch_registers (struct target_ops *ops,
   else
     is_dsp = 0;
 
-  tid = ptid_get_lwp (inferior_ptid);
+  tid = ptid_get_lwp (ptid);
   if (tid == 0)
-    tid = ptid_get_pid (inferior_ptid);
+    tid = ptid_get_pid (ptid);
 
   if (regno == -1 || (!is_fp && !is_dsp))
     {
@@ -286,14 +287,15 @@ mips64_linux_regsets_fetch_registers (struct target_ops *ops,
     }
 
   if (is_dsp)
-    super_fetch_registers (ops, regcache, regno);
+    super_fetch_registers (ops, regcache, ptid, regno);
   else if (regno == -1 && have_dsp)
     {
       for (regi = mips_regnum (gdbarch)->dspacc;
           regi < mips_regnum (gdbarch)->dspacc + 6;
           regi++)
-       super_fetch_registers (ops, regcache, regi);
-      super_fetch_registers (ops, regcache, mips_regnum (gdbarch)->dspctl);
+       super_fetch_registers (ops, regcache, ptid, regi);
+      super_fetch_registers (ops, regcache, ptid,
+                            mips_regnum (gdbarch)->dspctl);
     }
 }
 
@@ -381,16 +383,17 @@ mips64_linux_regsets_store_registers (struct target_ops *ops,
 
 static void
 mips64_linux_fetch_registers (struct target_ops *ops,
-                             struct regcache *regcache, int regnum)
+                             struct regcache *regcache,
+                             ptid_t ptid, int regnum)
 {
   /* Unless we already know that PTRACE_GETREGS does not work, try it.  */
   if (have_ptrace_regsets)
-    mips64_linux_regsets_fetch_registers (ops, regcache, regnum);
+    mips64_linux_regsets_fetch_registers (ops, regcache, ptid, 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 (ops, regcache, regnum);
+    super_fetch_registers (ops, regcache, ptid, regnum);
 }
 
 /* Store REGNO (or all registers if REGNO == -1) to the target
index b7c19dc85f08d2ec43bc30aab8b47419dc661e6d..a111e9ceda1b5fb2438ac256150cc333d354d528 100644 (file)
@@ -40,14 +40,15 @@ getregs_supplies (struct gdbarch *gdbarch, int regno)
 
 static void
 mipsnbsd_fetch_inferior_registers (struct target_ops *ops,
-                                  struct regcache *regcache, int regno)
+                                  struct regcache *regcache,
+                                  ptid_t ptid, int regno)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   if (regno == -1 || getregs_supplies (gdbarch, regno))
     {
       struct reg regs;
 
-      if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_GETREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &regs, 0) == -1)
        perror_with_name (_("Couldn't get registers"));
       
@@ -61,7 +62,7 @@ mipsnbsd_fetch_inferior_registers (struct target_ops *ops,
     {
       struct fpreg fpregs;
 
-      if (ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_GETFPREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't get floating point status"));
 
@@ -71,20 +72,21 @@ mipsnbsd_fetch_inferior_registers (struct target_ops *ops,
 
 static void
 mipsnbsd_store_inferior_registers (struct target_ops *ops,
-                                  struct regcache *regcache, int regno)
+                                  struct regcache *regcache,
+                                  ptid_t ptid, int regno)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   if (regno == -1 || getregs_supplies (gdbarch, regno))
     {
       struct reg regs;
 
-      if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_GETREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &regs, 0) == -1)
        perror_with_name (_("Couldn't get registers"));
 
       mipsnbsd_fill_reg (regcache, (char *) &regs, regno);
 
-      if (ptrace (PT_SETREGS, ptid_get_pid (inferior_ptid), 
+      if (ptrace (PT_SETREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &regs, 0) == -1)
        perror_with_name (_("Couldn't write registers"));
 
@@ -97,13 +99,13 @@ mipsnbsd_store_inferior_registers (struct target_ops *ops,
     {
       struct fpreg fpregs; 
 
-      if (ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_GETFPREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't get floating point status"));
 
       mipsnbsd_fill_fpreg (regcache, (char *) &fpregs, regno);
 
-      if (ptrace (PT_SETFPREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_SETFPREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't write floating point status"));
     }
index 97af421981a61bfcdee17d9c90c3f4acfdd64ad0..b69e0495395f3c1179cd63e705292e76a2f5de96 100644 (file)
@@ -79,11 +79,12 @@ mips64obsd_collect_gregset (const struct regcache *regcache,
 
 static void
 mips64obsd_fetch_inferior_registers (struct target_ops *ops,
-                                    struct regcache *regcache, int regnum)
+                                    struct regcache *regcache,
+                                    ptid_t ptid, int regnum)
 {
   struct reg regs;
 
-  if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+  if (ptrace (PT_GETREGS, ptid_get_pid (ptid),
              (PTRACE_TYPE_ARG3) &regs, 0) == -1)
     perror_with_name (_("Couldn't get registers"));
 
@@ -95,17 +96,18 @@ mips64obsd_fetch_inferior_registers (struct target_ops *ops,
 
 static void
 mips64obsd_store_inferior_registers (struct target_ops *ops,
-                                    struct regcache *regcache, int regnum)
+                                    struct regcache *regcache,
+                                    ptid_t ptid, int regnum)
 {
   struct reg regs;
 
-  if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+  if (ptrace (PT_GETREGS, ptid_get_pid (ptid),
              (PTRACE_TYPE_ARG3) &regs, 0) == -1)
     perror_with_name (_("Couldn't get registers"));
 
   mips64obsd_collect_gregset (regcache, &regs, regnum);
 
-  if (ptrace (PT_SETREGS, ptid_get_pid (inferior_ptid),
+  if (ptrace (PT_SETREGS, ptid_get_pid (ptid),
              (PTRACE_TYPE_ARG3) &regs, 0) == -1)
     perror_with_name (_("Couldn't write registers"));
 }
index 13b5ccf99f1f91d2141d0a2a48a6696b61ab0722..f1994c5d8d4a3300de076dfcdba3fb8cabb80f47 100644 (file)
@@ -857,7 +857,8 @@ procfs_wait (struct target_ops *ops,
    and update gdb's idea of their current values.  */
 static void
 procfs_fetch_registers (struct target_ops *ops,
-                       struct regcache *regcache, int regno)
+                       struct regcache *regcache,
+                       ptid_t ptid, int regno)
 {
   union
   {
@@ -868,7 +869,7 @@ procfs_fetch_registers (struct target_ops *ops,
   reg;
   int regsize;
 
-  procfs_set_thread (inferior_ptid);
+  procfs_set_thread (ptid);
   if (devctl (ctl_fd, DCMD_PROC_GETGREG, &reg, sizeof (reg), &regsize) == EOK)
     nto_supply_gregset (regcache, (char *) &reg.greg);
   if (devctl (ctl_fd, DCMD_PROC_GETFPREG, &reg, sizeof (reg), &regsize)
@@ -1338,7 +1339,8 @@ get_regset (int regset, char *buf, int bufsize, int *regsize)
 
 static void
 procfs_store_registers (struct target_ops *ops,
-                       struct regcache *regcache, int regno)
+                       struct regcache *regcache,
+                       ptid_t ptid, int regno)
 {
   union
   {
@@ -1351,9 +1353,9 @@ procfs_store_registers (struct target_ops *ops,
   int len, regset, regsize, dev_set, err;
   char *data;
 
-  if (ptid_equal (inferior_ptid, null_ptid))
+  if (ptid_equal (ptid, null_ptid))
     return;
-  procfs_set_thread (inferior_ptid);
+  procfs_set_thread (ptid);
 
   if (regno == -1)
     {
index 823c063643a771cd06dc93db9caf35e2c1576004..c96113b29f8bf416f283a75bda1632ef59edc63e 100644 (file)
@@ -117,11 +117,12 @@ getfpregs_supplies (struct gdbarch *gdbarch, int regno)
 
 static void
 ppcfbsd_fetch_inferior_registers (struct target_ops *ops,
-                                 struct regcache *regcache, int regno)
+                                 struct regcache *regcache,
+                                 ptid_t ptid, int regno)
 {
   gdb_gregset_t regs;
 
-  if (ptrace (PT_GETREGS, ptid_get_lwp (inferior_ptid),
+  if (ptrace (PT_GETREGS, ptid_get_lwp (ptid),
              (PTRACE_TYPE_ARG3) &regs, 0) == -1)
     perror_with_name (_("Couldn't get registers"));
 
@@ -132,7 +133,7 @@ ppcfbsd_fetch_inferior_registers (struct target_ops *ops,
       const struct regset *fpregset = ppc_fbsd_fpregset ();
       gdb_fpregset_t fpregs;
 
-      if (ptrace (PT_GETFPREGS, ptid_get_lwp (inferior_ptid),
+      if (ptrace (PT_GETFPREGS, ptid_get_lwp (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't get FP registers"));
 
@@ -145,17 +146,18 @@ ppcfbsd_fetch_inferior_registers (struct target_ops *ops,
 
 static void
 ppcfbsd_store_inferior_registers (struct target_ops *ops,
-                                 struct regcache *regcache, int regno)
+                                 struct regcache *regcache,
+                                 ptid_t ptid, int regno)
 {
   gdb_gregset_t regs;
 
-  if (ptrace (PT_GETREGS, ptid_get_lwp (inferior_ptid),
+  if (ptrace (PT_GETREGS, ptid_get_lwp (ptid),
              (PTRACE_TYPE_ARG3) &regs, 0) == -1)
     perror_with_name (_("Couldn't get registers"));
 
   fill_gregset (regcache, &regs, regno);
 
-  if (ptrace (PT_SETREGS, ptid_get_lwp (inferior_ptid),
+  if (ptrace (PT_SETREGS, ptid_get_lwp (ptid),
              (PTRACE_TYPE_ARG3) &regs, 0) == -1)
     perror_with_name (_("Couldn't write registers"));
 
@@ -163,13 +165,13 @@ ppcfbsd_store_inferior_registers (struct target_ops *ops,
     {
       gdb_fpregset_t fpregs;
 
-      if (ptrace (PT_GETFPREGS, ptid_get_lwp (inferior_ptid),
+      if (ptrace (PT_GETFPREGS, ptid_get_lwp (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't get FP registers"));
 
       fill_fpregset (regcache, &fpregs, regno);
 
-      if (ptrace (PT_SETFPREGS, ptid_get_lwp (inferior_ptid),
+      if (ptrace (PT_SETFPREGS, ptid_get_lwp (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't set FP registers"));
     }
index a56d154d3126c69431eff0717d6b4bcbe15f9d96..e7070ccd37884398a922fb221ca486a1159666ce 100644 (file)
@@ -807,14 +807,15 @@ fetch_ppc_registers (struct regcache *regcache, int tid)
    point registers depending upon the value of regno.  */
 static void
 ppc_linux_fetch_inferior_registers (struct target_ops *ops,
-                                   struct regcache *regcache, int regno)
+                                   struct regcache *regcache,
+                                   ptid_t ptid, int regno)
 {
   /* Overload thread id onto process id.  */
-  int tid = ptid_get_lwp (inferior_ptid);
+  int tid = ptid_get_lwp (ptid);
 
   /* No thread id, just use process id.  */
   if (tid == 0)
-    tid = ptid_get_pid (inferior_ptid);
+    tid = ptid_get_pid (ptid);
 
   if (regno == -1)
     fetch_ppc_registers (regcache, tid);
index 21d927cc1485d6200061b691adeade5dde89227f..f2b837b3c00658574bdf55a755434953b77cc09d 100644 (file)
@@ -78,7 +78,8 @@ getfpregs_supplies (struct gdbarch *gdbarch, int regnum)
 
 static void
 ppcnbsd_fetch_inferior_registers (struct target_ops *ops,
-                                 struct regcache *regcache, int regnum)
+                                 struct regcache *regcache,
+                                 ptid_t ptid, int regnum)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 
@@ -86,7 +87,7 @@ ppcnbsd_fetch_inferior_registers (struct target_ops *ops,
     {
       struct reg regs;
 
-      if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_GETREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &regs, 0) == -1)
         perror_with_name (_("Couldn't get registers"));
 
@@ -98,7 +99,7 @@ ppcnbsd_fetch_inferior_registers (struct target_ops *ops,
     {
       struct fpreg fpregs;
 
-      if (ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_GETFPREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't get FP registers"));
 
index 1a39e4629597e3092b2fdafc1cb92f83ab6a4645..0bb6f9f5d26b7762173973e5d49654b3558cfc8d 100644 (file)
@@ -72,11 +72,12 @@ getfpregs_supplies (struct gdbarch *gdbarch, int regnum)
 
 static void
 ppcobsd_fetch_registers (struct target_ops *ops,
-                        struct regcache *regcache, int regnum)
+                        struct regcache *regcache,
+                        ptid_t ptid, int regnum)
 {
   struct reg regs;
 
-  if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+  if (ptrace (PT_GETREGS, ptid_get_pid (ptid),
              (PTRACE_TYPE_ARG3) &regs, 0) == -1)
     perror_with_name (_("Couldn't get registers"));
 
@@ -93,7 +94,7 @@ ppcobsd_fetch_registers (struct target_ops *ops,
     {
       struct fpreg fpregs;
 
-      if (ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_GETFPREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
        perror_with_name (_("Couldn't get floating point status"));
 
index 795dae7a4da9030d13111bc14caa1e599063e392..9f518c2b535daae3b1ecfabfbcf9a598693a7c70 100644 (file)
@@ -145,7 +145,7 @@ register_in_thread_descriptor_p (const struct ravenscar_reg_info *reg_info,
 static void
 ppc_ravenscar_generic_fetch_registers
   (const struct ravenscar_reg_info *reg_info,
-   struct regcache *regcache, int regnum)
+   struct regcache *regcache, ptid_t ptid, int regnum)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   const int num_regs = gdbarch_num_regs (gdbarch);
@@ -154,7 +154,7 @@ ppc_ravenscar_generic_fetch_registers
   CORE_ADDR thread_descriptor_address;
 
   /* The tid is the thread_id field, which is a pointer to the thread.  */
-  thread_descriptor_address = (CORE_ADDR) ptid_get_tid (inferior_ptid);
+  thread_descriptor_address = (CORE_ADDR) ptid_get_tid (ptid);
 
   /* Read registers.  */
   for (current_regnum = 0; current_regnum < num_regs; current_regnum++)
@@ -215,9 +215,10 @@ static const struct ravenscar_reg_info ppc_reg_info =
    for most PowerPC targets.  */
 
 static void
-ppc_ravenscar_powerpc_fetch_registers (struct regcache *regcache, int regnum)
+ppc_ravenscar_powerpc_fetch_registers (struct regcache *regcache, ptid_t ptid,
+                                      int regnum)
 {
-  ppc_ravenscar_generic_fetch_registers (&ppc_reg_info, regcache, regnum);
+  ppc_ravenscar_generic_fetch_registers (&ppc_reg_info, regcache, ptid, regnum);
 }
 
 /* Implement the to_store_registers ravenscar_arch_ops method
@@ -258,9 +259,11 @@ static const struct ravenscar_reg_info e500_reg_info =
    for E500 targets.  */
 
 static void
-ppc_ravenscar_e500_fetch_registers (struct regcache *regcache, int regnum)
+ppc_ravenscar_e500_fetch_registers (struct regcache *regcache, ptid_t ptid,
+                                   int regnum)
 {
-  ppc_ravenscar_generic_fetch_registers (&e500_reg_info, regcache, regnum);
+  ppc_ravenscar_generic_fetch_registers (&e500_reg_info, regcache, ptid,
+                                        regnum);
 }
 
 /* Implement the to_store_registers ravenscar_arch_ops method
index d39830cb692f5ecc74550de07fcd486a440d3b2c..188ad5515737a67612f9a563552913d118ee09a1 100644 (file)
@@ -158,16 +158,13 @@ ps_pdwrite (gdb_ps_prochandle_t ph, psaddr_t addr,
 ps_err_e
 ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, prgregset_t gregset)
 {
-  struct cleanup *old_chain = save_inferior_ptid ();
   struct regcache *regcache;
+  ptid_t ptid = ptid_build (ptid_get_pid (ph->ptid), lwpid, 0);
 
-  inferior_ptid = ptid_build (ptid_get_pid (ph->ptid), lwpid, 0);
-  regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
-
-  target_fetch_registers (regcache, -1);
+  regcache = get_thread_arch_regcache (ptid, target_gdbarch ());
+  target_fetch_registers (regcache, ptid, -1);
   fill_gregset (regcache, (gdb_gregset_t *) gregset, -1);
 
-  do_cleanups (old_chain);
   return PS_OK;
 }
 
@@ -197,16 +194,13 @@ ps_err_e
 ps_lgetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
               gdb_prfpregset_t *fpregset)
 {
-  struct cleanup *old_chain = save_inferior_ptid ();
   struct regcache *regcache;
+  ptid_t ptid = ptid_build (ptid_get_pid (ph->ptid), lwpid, 0);
 
-  inferior_ptid = ptid_build (ptid_get_pid (ph->ptid), lwpid, 0);
-  regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
-
-  target_fetch_registers (regcache, -1);
+  regcache = get_thread_arch_regcache (ptid, target_gdbarch ());
+  target_fetch_registers (regcache, ptid, -1);
   fill_fpregset (regcache, (gdb_fpregset_t *) fpregset, -1);
 
-  do_cleanups (old_chain);
   return PS_OK;
 }
 
index 2269016ce8f629f3d98231f6d93d9ad8b6d76529..c7b7dab1d43bfc404b41b0c143295bd7d8b5cb93 100644 (file)
@@ -115,7 +115,7 @@ static void procfs_resume (struct target_ops *,
 static void procfs_interrupt (struct target_ops *self, ptid_t);
 static void procfs_files_info (struct target_ops *);
 static void procfs_fetch_registers (struct target_ops *,
-                                   struct regcache *, int);
+                                   struct regcache *, ptid_t, int);
 static void procfs_store_registers (struct target_ops *,
                                    struct regcache *, int);
 static void procfs_pass_signals (struct target_ops *self,
@@ -3215,19 +3215,20 @@ do_detach (int signo)
 
 static void
 procfs_fetch_registers (struct target_ops *ops,
-                       struct regcache *regcache, int regnum)
+                       struct regcache *regcache,
+                       ptid_t ptid, int regnum)
 {
   gdb_gregset_t *gregs;
   procinfo *pi;
-  int pid = ptid_get_pid (inferior_ptid);
-  int tid = ptid_get_lwp (inferior_ptid);
+  int pid = ptid_get_pid (ptid);
+  int tid = ptid_get_lwp (ptid);
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 
   pi = find_procinfo_or_die (pid, tid);
 
   if (pi == NULL)
     error (_("procfs: fetch_registers failed to find procinfo for %s"),
-          target_pid_to_str (inferior_ptid));
+          target_pid_to_str (ptid));
 
   gregs = proc_get_gregs (pi);
   if (gregs == NULL)
index d44c9810f69bf255f4b7fbee07a967db97e9d8f3..12a4eab26914bdddae5c37d1bc954a63a7b058d6 100644 (file)
@@ -57,8 +57,6 @@ static ptid_t ravenscar_running_thread (void);
 static char *ravenscar_extra_thread_info (struct target_ops *self,
                                          struct thread_info *tp);
 static int ravenscar_thread_alive (struct target_ops *ops, ptid_t ptid);
-static void ravenscar_fetch_registers (struct target_ops *ops,
-                                       struct regcache *regcache, int regnum);
 static void ravenscar_store_registers (struct target_ops *ops,
                                        struct regcache *regcache, int regnum);
 static void ravenscar_prepare_to_store (struct target_ops *self,
@@ -264,22 +262,22 @@ ravenscar_pid_to_str (struct target_ops *ops, ptid_t ptid)
 }
 
 static void
-ravenscar_fetch_registers (struct target_ops *ops,
-                           struct regcache *regcache, int regnum)
+ravenscar_fetch_registers (struct target_ops *ops, struct regcache *regcache,
+                          ptid_t ptid, int regnum)
 {
   struct target_ops *beneath = find_target_beneath (ops);
 
   if (!ravenscar_runtime_initialized ()
-      || ptid_equal (inferior_ptid, base_magic_null_ptid)
-      || ptid_equal (inferior_ptid, ravenscar_running_thread ()))
-    beneath->to_fetch_registers (beneath, regcache, regnum);
+      || ptid_equal (ptid, base_magic_null_ptid)
+      || ptid_equal (ptid, ravenscar_running_thread ()))
+    beneath->to_fetch_registers (beneath, regcache, ptid, regnum);
   else
     {
       struct gdbarch *gdbarch = get_regcache_arch (regcache);
       struct ravenscar_arch_ops *arch_ops
        = gdbarch_ravenscar_ops (gdbarch);
 
-      arch_ops->to_fetch_registers (regcache, regnum);
+      arch_ops->to_fetch_registers (regcache, ptid, regnum);
     }
 }
 
index 9497d0f98a19deacd916389bc58b63afbcb3f3e9..2413153010eb9f89ba843a5e126dd5e8777b876f 100644 (file)
@@ -24,7 +24,7 @@
 
 struct ravenscar_arch_ops
 {
-  void (*to_fetch_registers) (struct regcache *, int);
+  void (*to_fetch_registers) (struct regcache *, ptid_t, int);
   void (*to_store_registers) (struct regcache *, int);
   void (*to_prepare_to_store) (struct regcache *);
 };
index f7683f237f43f66f08b3deb296f8bd14a7561fe3..3f6cc859474806974669d1991c77ac73c2bceb39 100644 (file)
@@ -1420,12 +1420,13 @@ record_btrace_remove_breakpoint (struct target_ops *ops,
 
 static void
 record_btrace_fetch_registers (struct target_ops *ops,
-                              struct regcache *regcache, int regno)
+                              struct regcache *regcache,
+                              ptid_t ptid, int regno)
 {
   struct btrace_insn_iterator *replay;
   struct thread_info *tp;
 
-  tp = find_thread_ptid (inferior_ptid);
+  tp = find_thread_ptid (ptid);
   gdb_assert (tp != NULL);
 
   replay = tp->btrace.replay;
@@ -1453,7 +1454,7 @@ record_btrace_fetch_registers (struct target_ops *ops,
     {
       struct target_ops *t = ops->beneath;
 
-      t->to_fetch_registers (t, regcache, regno);
+      t->to_fetch_registers (t, regcache, ptid, regno);
     }
 }
 
index bd95acc6b1854753eb5da541cd7934eb3b8c9113..0b04f0fbb73c868199eba68303c7a1101eea6433 100644 (file)
@@ -796,7 +796,7 @@ record_full_core_open_1 (const char *name, int from_tty)
   int i;
 
   /* Get record_full_core_regbuf.  */
-  target_fetch_registers (regcache, -1);
+  target_fetch_registers (regcache, inferior_ptid, -1);
   record_full_core_regbuf = (gdb_byte *) xmalloc (MAX_REGISTER_SIZE * regnum);
   for (i = 0; i < regnum; i ++)
     regcache_raw_collect (regcache, i,
@@ -2045,7 +2045,7 @@ record_full_core_kill (struct target_ops *ops)
 static void
 record_full_core_fetch_registers (struct target_ops *ops,
                                  struct regcache *regcache,
-                                 int regno)
+                                 ptid_t ptid, int regno)
 {
   if (regno < 0)
     {
index 0728a03b65d60df0d032bfe9518d663d632523f8..bdf0bcbc82c08d89bf84bf3c0d260d96ee5ba076 100644 (file)
@@ -659,7 +659,7 @@ regcache_raw_update (struct regcache *regcache, int regnum)
       struct cleanup *old_chain = save_inferior_ptid ();
 
       inferior_ptid = regcache->ptid;
-      target_fetch_registers (regcache, regnum);
+      target_fetch_registers (regcache, inferior_ptid, regnum);
       do_cleanups (old_chain);
 
       /* A number of targets can't access the whole set of raw
index b0c68c617e365c0ea18ac2eca525598b688ffbb5..609ae84faca369315ded9de747355002d49f994c 100644 (file)
@@ -426,16 +426,18 @@ one2one_register_sim_regno (struct gdbarch *gdbarch, int regnum)
 
 static void
 gdbsim_fetch_register (struct target_ops *ops,
-                      struct regcache *regcache, int regno)
+                      struct regcache *regcache,
+                      ptid_t ptid, int regno)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  struct inferior *inf = find_inferior_ptid (ptid);
   struct sim_inferior_data *sim_data
-    = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
+    = get_sim_inferior_data (inf, SIM_INSTANCE_NEEDED);
 
   if (regno == -1)
     {
       for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
-       gdbsim_fetch_register (ops, regcache, regno);
+       gdbsim_fetch_register (ops, regcache, ptid, regno);
       return;
     }
 
index 2f34c4c300f0f529bd726358ff980622459753dd..b1b1c580386c29027635d70f93e3c0822f387833 100644 (file)
@@ -7704,14 +7704,14 @@ set_remote_traceframe (void)
 }
 
 static void
-remote_fetch_registers (struct target_ops *ops,
-                       struct regcache *regcache, int regnum)
+remote_fetch_registers (struct target_ops *ops, struct regcache *regcache,
+                       ptid_t ptid, int regnum)
 {
   struct remote_arch_state *rsa = get_remote_arch_state ();
   int i;
 
   set_remote_traceframe ();
-  set_general_thread (inferior_ptid);
+  set_general_thread (ptid);
 
   if (regnum >= 0)
     {
index f42847bfeab8ad6d03c96a161238283a262f98d1..7362df9580d5538fa3eb73b0bcf5f65004941ec3 100644 (file)
@@ -159,7 +159,7 @@ rs6000_ptrace64 (int req, int id, long long addr, int data, void *buf)
 /* Fetch register REGNO from the inferior.  */
 
 static void
-fetch_register (struct regcache *regcache, int regno)
+fetch_register (struct regcache *regcache, ptid_t ptid, int regno)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int addr[MAX_REGISTER_SIZE];
@@ -172,7 +172,7 @@ fetch_register (struct regcache *regcache, int regno)
 
   /* Floating-point registers.  */
   if (isfloat)
-    rs6000_ptrace32 (PT_READ_FPR, ptid_get_pid (inferior_ptid), addr, nr, 0);
+    rs6000_ptrace32 (PT_READ_FPR, ptid_get_pid (ptid), addr, nr, 0);
 
   /* Bogus register number.  */
   else if (nr < 0)
@@ -188,14 +188,14 @@ fetch_register (struct regcache *regcache, int regno)
   else
     {
       if (!ARCH64 ())
-       *addr = rs6000_ptrace32 (PT_READ_GPR, ptid_get_pid (inferior_ptid),
+       *addr = rs6000_ptrace32 (PT_READ_GPR, ptid_get_pid (ptid),
                                 (int *) nr, 0, 0);
       else
        {
          /* PT_READ_GPR requires the buffer parameter to point to long long,
             even if the register is really only 32 bits.  */
          long long buf;
-         rs6000_ptrace64 (PT_READ_GPR, ptid_get_pid (inferior_ptid),
+         rs6000_ptrace64 (PT_READ_GPR, ptid_get_pid (ptid),
                           nr, 0, &buf);
          if (register_size (gdbarch, regno) == 8)
            memcpy (addr, &buf, 8);
@@ -281,11 +281,12 @@ store_register (struct regcache *regcache, int regno)
 
 static void
 rs6000_fetch_inferior_registers (struct target_ops *ops,
-                                struct regcache *regcache, int regno)
+                                struct regcache *regcache,
+                                ptid_t ptid, int regno)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   if (regno != -1)
-    fetch_register (regcache, regno);
+    fetch_register (regcache, ptid, regno);
 
   else
     {
@@ -296,25 +297,25 @@ rs6000_fetch_inferior_registers (struct target_ops *ops,
            regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
           regno++)
        {
-         fetch_register (regcache, regno);
+         fetch_register (regcache, ptid, regno);
        }
 
       /* Read general purpose floating point registers.  */
       if (tdep->ppc_fp0_regnum >= 0)
         for (regno = 0; regno < ppc_num_fprs; regno++)
-          fetch_register (regcache, tdep->ppc_fp0_regnum + regno);
+          fetch_register (regcache, ptid, tdep->ppc_fp0_regnum + regno);
 
       /* Read special registers.  */
-      fetch_register (regcache, gdbarch_pc_regnum (gdbarch));
-      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);
+      fetch_register (regcache, ptid, gdbarch_pc_regnum (gdbarch));
+      fetch_register (regcache, ptid, tdep->ppc_ps_regnum);
+      fetch_register (regcache, ptid, tdep->ppc_cr_regnum);
+      fetch_register (regcache, ptid, tdep->ppc_lr_regnum);
+      fetch_register (regcache, ptid, tdep->ppc_ctr_regnum);
+      fetch_register (regcache, ptid, tdep->ppc_xer_regnum);
       if (tdep->ppc_fpscr_regnum >= 0)
-        fetch_register (regcache, tdep->ppc_fpscr_regnum);
+        fetch_register (regcache, ptid, tdep->ppc_fpscr_regnum);
       if (tdep->ppc_mq_regnum >= 0)
-       fetch_register (regcache, tdep->ppc_mq_regnum);
+       fetch_register (regcache, ptid, tdep->ppc_mq_regnum);
     }
 }
 
index 3544588de6b54166abe1c4b61c1b103aeb483c7c..1703844e0858d5d2c6be82b4e86f1069a3c96279 100644 (file)
@@ -376,9 +376,10 @@ check_regset (int tid, int regset, int regsize)
    this for all registers.  */
 static void
 s390_linux_fetch_inferior_registers (struct target_ops *ops,
-                                    struct regcache *regcache, int regnum)
+                                    struct regcache *regcache,
+                                    ptid_t ptid, int regnum)
 {
-  int tid = s390_inferior_tid ();
+  int tid = s390_inferior_tid (ptid);
 
   if (regnum == -1 || S390_IS_GREGSET_REGNUM (regnum))
     fetch_regs (regcache, tid);
index 90c9689899d9157f5c07e384a0d181f15b46f4b8..d1ece86cddda17b00c5832258fde006597b46e82 100644 (file)
 
 static void
 shnbsd_fetch_inferior_registers (struct target_ops *ops,
-                                struct regcache *regcache, int regno)
+                                struct regcache *regcache,
+                                ptid_t ptid, int regno)
 {
   if (regno == -1 || GETREGS_SUPPLIES (get_regcache_arch (regcache), regno))
     {
       struct reg inferior_registers;
 
-      if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_GETREGS, ptid_get_pid (ptid),
                  (PTRACE_TYPE_ARG3) &inferior_registers, 0) == -1)
        perror_with_name (_("Couldn't get registers"));
 
index a09a3ab9a8bc56f367e3ba1537f5674f0a7f491f..56fdc963802a9947741bc8564ace17743e0db737 100644 (file)
@@ -452,7 +452,8 @@ sol_thread_wait (struct target_ops *ops,
 
 static void
 sol_thread_fetch_registers (struct target_ops *ops,
-                           struct regcache *regcache, int regnum)
+                           struct regcache *regcache,
+                           ptid_t ptid, int regnum)
 {
   thread_t thread;
   td_thrhandle_t thandle;
@@ -463,15 +464,15 @@ sol_thread_fetch_registers (struct target_ops *ops,
   gdb_fpregset_t *fpregset_p = &fpregset;
   struct target_ops *beneath = find_target_beneath (ops);
 
-  if (!ptid_tid_p (inferior_ptid))
+  if (!ptid_tid_p (ptid))
     {
       /* It's an LWP; pass the request on to the layer beneath.  */
-      beneath->to_fetch_registers (beneath, regcache, regnum);
+      beneath->to_fetch_registers (beneath, regcache, ptid, regnum);
       return;
     }
 
-  /* Solaris thread: convert INFERIOR_PTID into a td_thrhandle_t.  */
-  thread = ptid_get_tid (inferior_ptid);
+  /* Solaris thread: convert PTID into a td_thrhandle_t.  */
+  thread = ptid_get_tid (ptid);
   if (thread == 0)
     error (_("sol_thread_fetch_registers: thread == 0"));
 
index b058ccf1e78434c4c9a4b19d0530344b98739e80..b423ce5c403a7b946ea0d884f98fa8fcb0bcd404 100644 (file)
@@ -135,7 +135,8 @@ sparc32_fpregset_supplies_p (struct gdbarch *gdbarch, int regnum)
 
 void
 sparc_fetch_inferior_registers (struct target_ops *ops,
-                               struct regcache *regcache, int regnum)
+                               struct regcache *regcache,
+                               ptid_t ptid, int regnum)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int pid;
@@ -153,9 +154,9 @@ sparc_fetch_inferior_registers (struct target_ops *ops,
      These functions should instead be paramaterized with an explicit
      object (struct regcache, struct thread_info?) into which the LWPs
      registers can be written.  */
-  pid = ptid_get_lwp (inferior_ptid);
+  pid = ptid_get_lwp (ptid);
   if (pid == 0)
-    pid = ptid_get_pid (inferior_ptid);
+    pid = ptid_get_pid (ptid);
 
   if (regnum == SPARC_G0_REGNUM)
     {
index b598e197f1e8512af892d6952cd49f1e1f389037..bfa6961fe988831a0844227f0c27b6f9d9c102b1 100644 (file)
@@ -45,7 +45,7 @@ extern int sparc32_fpregset_supplies_p (struct gdbarch *gdbarch, int regnum);
 extern struct target_ops *sparc_target (void);
 
 extern void sparc_fetch_inferior_registers (struct target_ops *,
-                                           struct regcache *, int);
+                                           struct regcache *, ptid_t, int);
 extern void sparc_store_inferior_registers (struct target_ops *,
                                            struct regcache *, int);
 
index 89f960aa24d9fc9683d071c38ebf9dbec643a077..0573f8345d4dfcb1aa8c1b58886e07a1b212cf59 100644 (file)
@@ -25,8 +25,6 @@
 #include "ravenscar-thread.h"
 #include "sparc-ravenscar-thread.h"
 
-static void sparc_ravenscar_fetch_registers (struct regcache *regcache,
-                                             int regnum);
 static void sparc_ravenscar_store_registers (struct regcache *regcache,
                                              int regnum);
 static void sparc_ravenscar_prepare_to_store (struct regcache *regcache);
@@ -101,7 +99,8 @@ register_in_thread_descriptor_p (int regnum)
    thread.  */
 
 static void
-sparc_ravenscar_fetch_registers (struct regcache *regcache, int regnum)
+sparc_ravenscar_fetch_registers (struct regcache *regcache, ptid_t ptid,
+                                int regnum)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   const int sp_regnum = gdbarch_sp_regnum (gdbarch);
@@ -112,7 +111,7 @@ sparc_ravenscar_fetch_registers (struct regcache *regcache, int regnum)
   ULONGEST stack_address;
 
   /* The tid is the thread_id field, which is a pointer to the thread.  */
-  thread_descriptor_address = (CORE_ADDR) ptid_get_tid (inferior_ptid);
+  thread_descriptor_address = (CORE_ADDR) ptid_get_tid (ptid);
 
   /* Read the saved SP in the context buffer.  */
   current_address = thread_descriptor_address
index b99a1a3de3d31b7e77a575cc49b6fe7004531ce8..6516a10b76d1c9ca4b69a5f7318afec5ea01f27a 100644 (file)
@@ -140,8 +140,8 @@ spu_region_ok_for_hw_watchpoint (struct target_ops *self,
 
 /* Override the to_fetch_registers routine.  */
 static void
-spu_fetch_registers (struct target_ops *ops,
-                    struct regcache *regcache, int regno)
+spu_fetch_registers (struct target_ops *ops, struct regcache *regcache,
+                    ptid_t ptid, int regno)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
@@ -152,12 +152,12 @@ spu_fetch_registers (struct target_ops *ops,
   /* This version applies only if we're currently in spu_run.  */
   if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_spu)
     {
-      ops_beneath->to_fetch_registers (ops_beneath, regcache, regno);
+      ops_beneath->to_fetch_registers (ops_beneath, regcache, ptid, regno);
       return;
     }
 
   /* We must be stopped on a spu_run system call.  */
-  if (!parse_spufs_run (inferior_ptid, &spufs_fd, &spufs_addr))
+  if (!parse_spufs_run (ptid, &spufs_fd, &spufs_addr))
     return;
 
   /* The ID register holds the spufs file handle.  */
index 470b7e44d879ab2bedcfe9335f4e37b03db04eed..01ab150e3a0d1eb94c0d27aee853c2f5753268b8 100644 (file)
@@ -159,28 +159,30 @@ debug_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2
 }
 
 static void
-delegate_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
+delegate_fetch_registers (struct target_ops *self, struct regcache *arg1, ptid_t arg2, int arg3)
 {
   self = self->beneath;
-  self->to_fetch_registers (self, arg1, arg2);
+  self->to_fetch_registers (self, arg1, arg2, arg3);
 }
 
 static void
-tdefault_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
+tdefault_fetch_registers (struct target_ops *self, struct regcache *arg1, ptid_t arg2, int arg3)
 {
 }
 
 static void
-debug_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
+debug_fetch_registers (struct target_ops *self, struct regcache *arg1, ptid_t arg2, int arg3)
 {
   fprintf_unfiltered (gdb_stdlog, "-> %s->to_fetch_registers (...)\n", debug_target.to_shortname);
-  debug_target.to_fetch_registers (&debug_target, arg1, arg2);
+  debug_target.to_fetch_registers (&debug_target, arg1, arg2, arg3);
   fprintf_unfiltered (gdb_stdlog, "<- %s->to_fetch_registers (", debug_target.to_shortname);
   target_debug_print_struct_target_ops_p (&debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_struct_regcache_p (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
-  target_debug_print_int (arg2);
+  target_debug_print_ptid_t (arg2);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_int (arg3);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
index 0ff8515d3b731ff5929e5c9c68a20d124c1ecd67..e57789f15f37a916d504be84af2df55c92155766 100644 (file)
@@ -3585,9 +3585,9 @@ debug_print_register (const char * func,
 }
 
 void
-target_fetch_registers (struct regcache *regcache, int regno)
+target_fetch_registers (struct regcache *regcache, ptid_t ptid, int regno)
 {
-  current_target.to_fetch_registers (&current_target, regcache, regno);
+  current_target.to_fetch_registers (&current_target, regcache, ptid, regno);
   if (targetdebug)
     debug_print_register ("target_fetch_registers", regcache, regno);
 }
index 943a0e2e1a04c82775efda14ac21b6ee226ef5a5..24a138ff67c729a9079a442d5764d141567880f9 100644 (file)
@@ -468,7 +468,8 @@ struct target_ops
                       ptid_t, struct target_waitstatus *,
                       int TARGET_DEBUG_PRINTER (target_debug_print_options))
       TARGET_DEFAULT_FUNC (default_target_wait);
-    void (*to_fetch_registers) (struct target_ops *, struct regcache *, int)
+    void (*to_fetch_registers) (struct target_ops *, struct regcache *, ptid_t,
+                               int)
       TARGET_DEFAULT_IGNORE ();
     void (*to_store_registers) (struct target_ops *, struct regcache *, int)
       TARGET_DEFAULT_NORETURN (noprocess ());
@@ -1380,9 +1381,11 @@ extern ptid_t default_target_wait (struct target_ops *ops,
                                   struct target_waitstatus *status,
                                   int options);
 
-/* Fetch at least register REGNO, or all regs if regno == -1.  No result.  */
+/* Fetch at least register REGNO of thread PTID from the target and store it in
+   REGCACHE.  Fetch all registers if REGNO == -1.  */
 
-extern void target_fetch_registers (struct regcache *regcache, int regno);
+extern void target_fetch_registers (struct regcache *regcache, ptid_t ptid,
+                                   int 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
index c0833cf74bdc04a4a41a61055af168dc95686e54..5c47a3e0756857070fec1f0981487f0e3f6dc73c 100644 (file)
@@ -123,14 +123,15 @@ fill_fpregset (const struct regcache *regcache,
 
 static void
 fetch_inferior_registers (struct target_ops *ops,
-                         struct regcache *regcache, int regnum)
+                         struct regcache *regcache,
+                         ptid_t ptid, int regnum)
 {
   elf_gregset_t regs;
   int tid;
 
-  tid = ptid_get_lwp (inferior_ptid);
+  tid = ptid_get_lwp (ptid);
   if (tid == 0)
-    tid = ptid_get_pid (inferior_ptid);
+    tid = ptid_get_pid (ptid);
 
   if (ptrace (PTRACE_GETREGS, tid, 0, (PTRACE_TYPE_ARG3) &regs) < 0)
     perror_with_name (_("Couldn't get registers"));
index dbcd65d5dfac71424dfc690caf22d05e0eaf1522..268392993ec0e3428eda17aa3858d3ba6537d2c3 100644 (file)
@@ -848,8 +848,8 @@ traceframe_find_block_type (char type_wanted, int pos)
    requested register from it.  */
 
 static void
-tfile_fetch_registers (struct target_ops *ops,
-                      struct regcache *regcache, int regno)
+tfile_fetch_registers (struct target_ops *ops, struct regcache *regcache,
+                      ptid_t ptid, int regno)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int offset, regn, regsize, dummy;
index a8bc603679a2083b1be1b2fcb32b83894f0fa7f0..8d1cdf485652fabd1197880e5bdbdeb4482681c8 100644 (file)
@@ -64,11 +64,12 @@ vaxbsd_collect_gregset (const struct regcache *regcache,
 
 static void
 vaxbsd_fetch_inferior_registers (struct target_ops *ops,
-                                struct regcache *regcache, int regnum)
+                                struct regcache *regcache,
+                                ptid_t ptid, int regnum)
 {
   struct reg regs;
 
-  if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+  if (ptrace (PT_GETREGS, ptid_get_pid (ptid),
              (PTRACE_TYPE_ARG3) &regs, 0) == -1)
     perror_with_name (_("Couldn't get registers"));
 
index a177b38ea3cb80d3e459e78413049f98afe1b5d7..36ca90d36c3e69c9f22c6eef39a4764b405fdf7e 100644 (file)
@@ -531,9 +531,10 @@ do_windows_fetch_inferior_registers (struct regcache *regcache,
 
 static void
 windows_fetch_inferior_registers (struct target_ops *ops,
-                                 struct regcache *regcache, int r)
+                                 struct regcache *regcache,
+                                 ptid_t ptid, int r)
 {
-  windows_thread_info *th = thread_rec (ptid_get_tid (inferior_ptid), TRUE);
+  windows_thread_info *th = thread_rec (ptid_get_tid (ptid), TRUE);
 
   /* Check if current_thread exists.  Windows sometimes uses a non-existent
      thread id in its events.  */
index c29f0c71e66b3511f21089b27b2b08b11f0e1f9c..688ed5c7d6f71619973b508b0cd4f2d744f187e7 100644 (file)
@@ -168,13 +168,13 @@ supply_fpregset (struct regcache *regcache,
   return;
 }
 
-/* Fetch greg-register(s) from process/thread TID
-   and store value(s) in GDB's register array.  */
+/* Fetch greg-register(s) from process/thread PTID
+   and store value(s) in REGCACHE.  */
 
 static void
-fetch_gregs (struct regcache *regcache, int regnum)
+fetch_gregs (struct regcache *regcache, ptid_t ptid, int regnum)
 {
-  int tid = ptid_get_lwp (inferior_ptid);
+  int tid = ptid_get_lwp (ptid);
   gdb_gregset_t regs;
   int areg;
   
@@ -219,9 +219,9 @@ static int xtreg_high;
    interface provides special requests for this.  */
 
 static void
-fetch_xtregs (struct regcache *regcache, int regnum)
+fetch_xtregs (struct regcache *regcache, ptid_t ptid, int regnum)
 {
-  int tid = ptid_get_lwp (inferior_ptid);
+  int tid = ptid_get_lwp (ptid);
   const xtensa_regtable_t *ptr;
   char xtregs [XTENSA_ELF_XTREG_SIZE];
 
@@ -255,17 +255,18 @@ store_xtregs (struct regcache *regcache, int regnum)
 
 static void
 xtensa_linux_fetch_inferior_registers (struct target_ops *ops,
-                                      struct regcache *regcache, int regnum)
+                                      struct regcache *regcache,
+                                      ptid_t ptid, int regnum)
 {
   if (regnum == -1)
     {
-      fetch_gregs (regcache, regnum);
-      fetch_xtregs (regcache, regnum);
+      fetch_gregs (regcache, ptid, regnum);
+      fetch_xtregs (regcache, ptid, regnum);
     }
   else if ((regnum < xtreg_lo) || (regnum > xtreg_high))
-    fetch_gregs (regcache, regnum);
+    fetch_gregs (regcache, ptid, regnum);
   else
-    fetch_xtregs (regcache, regnum);
+    fetch_xtregs (regcache, ptid, regnum);
 }
 
 static void