Pass ptid to target_store_registers This patch adds a ptid parameter to the target_store_registers function and the to_store_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_store_registers>: Add ptid parameter. (target_store_registers): Likewise. * target.c (target_store_registers): Likewise. * aarch64-linux-nat.c (store_gregs_to_thread, store_fpregs_to_thread, aarch64_linux_store_inferior_registers): Add ptid parameter and use it. * aix-thread.c (aix_thread_store_registers): Add ptid parameter and use it. * amd64-linux-nat.c (amd64_linux_store_inferior_registers): Add ptid parameter and use it. * arm-linux-nat.c (store_fpregs, store_regs, store_wmmx_regs, store_vfp_regs, arm_linux_store_inferior_registers): Likewise. * arm-nbsd-nat.c (store_register, store_fp_register, armnbsd_store_registers): Likewise. * bsd-uthread.c (bsd_uthread_store_registers): Likewise. * hppa-linux-nat.c (store_register, hppa_linux_store_inferior_registers): Likewise. * i386-linux-nat.c (store_register, i386_linux_store_inferior_registers): Likewise. * ia64-linux-nat.c (ia64_linux_store_register, ia64_linux_store_registers): Likewise. * inf-child.c (inf_child_store_inferior_registers): Add ptid parameter. * inf-ptrace.c (inf_ptrace_store_register, inf_ptrace_store_registers): Likewise. * m68k-linux-nat.c (store_register, old_store_inferior_registers, m68k_linux_store_inferior_registers): Likewise. * mips-linux-nat.c (super_store_registers, mips64_linux_regsets_store_registers, mips64_linux_store_registers): Likewise. * ppc-linux-nat.c (ppc_linux_store_inferior_registers): Likewise. * ppc-nbsd-nat.c (ppcnbsd_store_inferior_registers): Likewise. * ppc-obsd-nat.c (ppcobsd_store_registers): Likewise. * ppc-ravenscar-thread.c (ppc_ravenscar_generic_store_registers): Add ptid parameter and use it. (ppc_ravenscar_powerpc_store_registers): Likewise. (ppc_ravenscar_e500_store_registers): Likewise. * proc-service.c (ps_lsetregs, ps_lsetfpregs): Add ptid parameter and use it. Don't set/restore inferior_ptid. * procfs.c (procfs_store_registers): Add ptid parameter and use it. * ravenscar-thread.c (ravenscar_store_registers): Add ptid parameter and use it. Remove declaration at top of file. * ravenscar-thread.h (struct ravenscar_arch_ops) <to_store_registers>: Add ptid parameter. * record-btrace.c (record_btrace_store_registers): Add ptid parameter and use it. * record-full.c (record_full_store_registers): Likewise. (record_full_core_store_registers): Add ptid parameter. * regcache.c (regcache_raw_write): Pass ptid to target_store_registers. * remote.c (remote_store_registers): Add ptid parameter and use it. * remote-sim.c (gdbsim_store_register): Likewise. * rs6000-aix-tdep.c (rs6000_push_dummy_call): Pass inferior_ptid to target_store_registers. * rs6000-lynx178-tdep.c (rs6000_lynx178_push_dummy_call): Likewise. * rs6000-nat.c (store_register, rs6000_store_inferior_registers): Add ptid parameter and use it. * s390-linux-nat.c (s390_linux_store_inferior_registers): Likewise. * sh-nbsd-nat.c (shnbsd_store_inferior_registers): Likewise. * sol-thread.c (sol_thread_store_registers): Likewise. * sparc-nat.c (sparc_store_inferior_registers): Likewise. * sparc-nat.h (sparc_store_inferior_registers): Likewise. * sparc-ravenscar-thread.c (sparc_ravenscar_store_registers): Add ptid parameter and use it. Remove declaration at top of file. * spu-linux-nat.c (spu_store_inferior_registers): Add ptid parameter and use it. * spu-multiarch.c (spu_store_registers): Likewise. * tilegx-linux-nat.c (store_inferior_registers): Likewise. * vax-bsd-nat.c (vaxbsd_store_inferior_registers): Likewise. * windows-nat.c (windows_store_inferior_registers): Likewise. * xtensa-linux-nat.c (store_gregs, store_xtregs, xtensa_linux_store_inferior_registers): Likewise.

diff --git a/gdb/aarch64-linux-nat.c b/gdb/aarch64-linux-nat.c
index 3fc3404..e17a4a2 100644
--- a/gdb/aarch64-linux-nat.c
+++ b/gdb/aarch64-linux-nat.c

@@ -190,7 +190,7 @@
    values in the GDB's register array.  */
 
 static void
-store_gregs_to_thread (const struct regcache *regcache)
+store_gregs_to_thread (const struct regcache *regcache, ptid_t ptid)
 {
   int ret, tid;
   elf_gregset_t regs;
@@ -200,7 +200,7 @@
   /* Make sure REGS can hold all registers contents on both aarch64
      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)
@@ -281,7 +281,7 @@
    values in the GDB's register array.  */
 
 static void
-store_fpregs_to_thread (const struct regcache *regcache)
+store_fpregs_to_thread (const struct regcache *regcache, ptid_t ptid)
 {
   int ret, tid;
   elf_fpregset_t regs;
@@ -291,7 +291,7 @@
   /* Make sure REGS can hold all VFP registers contents on both aarch64
      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;
 
@@ -365,17 +365,17 @@
 static void
 aarch64_linux_store_inferior_registers (struct target_ops *ops,
 					struct regcache *regcache,
-					int regno)
+					ptid_t ptid, int regno)
 {
   if (regno == -1)
     {
-      store_gregs_to_thread (regcache);
-      store_fpregs_to_thread (regcache);
+      store_gregs_to_thread (regcache, ptid);
+      store_fpregs_to_thread (regcache, ptid);
     }
   else if (regno < AARCH64_V0_REGNUM)
-    store_gregs_to_thread (regcache);
+    store_gregs_to_thread (regcache, ptid);
   else
-    store_fpregs_to_thread (regcache);
+    store_fpregs_to_thread (regcache, ptid);
 }
 
 /* Fill register REGNO (if it is a general-purpose register) in

diff --git a/gdb/aix-thread.c b/gdb/aix-thread.c
index b85c147..0414494 100644
--- a/gdb/aix-thread.c
+++ b/gdb/aix-thread.c

@@ -1657,17 +1657,18 @@
 
 static void
 aix_thread_store_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_store_registers (beneath, regcache, regno);
+  if (!PD_TID (ptid))
+    beneath->to_store_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)

diff --git a/gdb/amd64-linux-nat.c b/gdb/amd64-linux-nat.c
index a9f61cd..f9c81ea 100644
--- a/gdb/amd64-linux-nat.c
+++ b/gdb/amd64-linux-nat.c

@@ -212,15 +212,16 @@
 
 static void
 amd64_linux_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);
   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))
     {

diff --git a/gdb/arm-linux-nat.c b/gdb/arm-linux-nat.c
index 86ac33d..a1c50e2 100644
--- a/gdb/arm-linux-nat.c
+++ b/gdb/arm-linux-nat.c

@@ -107,13 +107,13 @@
    the contents from regcache.  */
 
 static void
-store_fpregs (const struct regcache *regcache)
+store_fpregs (const 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)
@@ -188,13 +188,13 @@
 }
 
 static void
-store_regs (const struct regcache *regcache)
+store_regs (const 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);
 
   /* Fetch the general registers.  */
   if (have_ptrace_getregset == TRIBOOL_TRUE)
@@ -262,13 +262,13 @@
 }
 
 static void
-store_wmmx_regs (const struct regcache *regcache)
+store_wmmx_regs (const 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)
@@ -328,7 +328,7 @@
 }
 
 static void
-store_vfp_regs (const struct regcache *regcache)
+store_vfp_regs (const struct regcache *regcache, ptid_t ptid)
 {
   gdb_byte regbuf[VFP_REGS_SIZE];
   int ret, regno, tid;
@@ -336,7 +336,7 @@
   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)
     {
@@ -414,34 +414,35 @@
 
 static void
 arm_linux_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);
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
   if (-1 == regno)
     {
-      store_regs (regcache);
+      store_regs (regcache, ptid);
       if (tdep->have_wmmx_registers)
-	store_wmmx_regs (regcache);
+	store_wmmx_regs (regcache, ptid);
       if (tdep->vfp_register_count > 0)
-	store_vfp_regs (regcache);
+	store_vfp_regs (regcache, ptid);
       if (tdep->have_fpa_registers)
-	store_fpregs (regcache);
+	store_fpregs (regcache, ptid);
     }
   else
     {
       if (regno < ARM_F0_REGNUM || regno == ARM_PS_REGNUM)
-	store_regs (regcache);
+	store_regs (regcache, ptid);
       else if ((regno >= ARM_F0_REGNUM) && (regno <= ARM_FPS_REGNUM))
-	store_fpregs (regcache);
+	store_fpregs (regcache, ptid);
       else if (tdep->have_wmmx_registers
 	       && regno >= ARM_WR0_REGNUM && regno <= ARM_WCGR7_REGNUM)
-	store_wmmx_regs (regcache);
+	store_wmmx_regs (regcache, ptid);
       else if (tdep->vfp_register_count > 0
 	       && regno >= ARM_D0_REGNUM
 	       && regno <= ARM_D0_REGNUM + tdep->vfp_register_count)
-	store_vfp_regs (regcache);
+	store_vfp_regs (regcache, ptid);
     }
 }
 

diff --git a/gdb/arm-nbsd-nat.c b/gdb/arm-nbsd-nat.c
index 8857e37..f59e564 100644
--- a/gdb/arm-nbsd-nat.c
+++ b/gdb/arm-nbsd-nat.c

@@ -211,13 +211,13 @@
 
 
 static void
-store_register (const struct regcache *regcache, int regno)
+store_register (const struct regcache *regcache, ptid_t ptid, int regno)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   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)
@@ -280,7 +280,7 @@
       break;
     }
 
-  ret = ptrace (PT_SETREGS, ptid_get_pid (inferior_ptid),
+  ret = ptrace (PT_SETREGS, ptid_get_pid (ptid),
 		(PTRACE_TYPE_ARG3) &inferior_registers, 0);
 
   if (ret < 0)
@@ -328,7 +328,7 @@
       inferior_registers.r_pc = pc_val | psr_val;
     }
 
-  ret = ptrace (PT_SETREGS, ptid_get_pid (inferior_ptid),
+  ret = ptrace (PT_SETREGS, ptid_get_pid (ptid),
 		(PTRACE_TYPE_ARG3) &inferior_registers, 0);
 
   if (ret < 0)
@@ -336,12 +336,12 @@
 }
 
 static void
-store_fp_register (const struct regcache *regcache, int regno)
+store_fp_register (const 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)
@@ -363,7 +363,7 @@
       break;
     }
 
-  ret = ptrace (PT_SETFPREGS, ptid_get_pid (inferior_ptid),
+  ret = ptrace (PT_SETFPREGS, ptid_get_pid (ptid),
 		(PTRACE_TYPE_ARG3) &inferior_fp_registers, 0);
 
   if (ret < 0)
@@ -371,7 +371,7 @@
 }
 
 static void
-store_fp_regs (const struct regcache *regcache)
+store_fp_regs (const struct regcache *regcache, ptid_t ptid)
 {
   struct fpreg inferior_fp_registers;
   int ret;
@@ -385,7 +385,7 @@
   regcache_raw_collect (regcache, ARM_FPS_REGNUM,
 			(char *) &inferior_fp_registers.fpr_fpsr);
 
-  ret = ptrace (PT_SETFPREGS, ptid_get_pid (inferior_ptid),
+  ret = ptrace (PT_SETFPREGS, ptid_get_pid (ptid),
 		(PTRACE_TYPE_ARG3) &inferior_fp_registers, 0);
 
   if (ret < 0)
@@ -394,19 +394,20 @@
 
 static void
 armnbsd_store_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)
-	store_register (regcache, regno);
+	store_register (regcache, regno, ptid);
       else
-	store_fp_register (regcache, regno);
+	store_fp_register (regcache, regno, ptid);
     }
   else
     {
-      store_regs (regcache);
-      store_fp_regs (regcache);
+      store_regs (regcache, ptid);
+      store_fp_regs (regcache, ptid);
     }
 }
 

diff --git a/gdb/bsd-uthread.c b/gdb/bsd-uthread.c
index c2c9866..04bd43b 100644
--- a/gdb/bsd-uthread.c
+++ b/gdb/bsd-uthread.c

@@ -309,13 +309,13 @@
 
 static void
 bsd_uthread_store_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);
   struct bsd_uthread_ops *uthread_ops
     = (struct bsd_uthread_ops *) gdbarch_data (gdbarch, bsd_uthread_data);
   struct target_ops *beneath = find_target_beneath (ops);
-  ptid_t ptid = inferior_ptid;
   CORE_ADDR addr = ptid_get_tid (ptid);
   CORE_ADDR active_addr;
 
@@ -330,7 +330,7 @@
     {
       /* Updating the thread that is currently running; pass the
          request to the layer beneath.  */
-      beneath->to_store_registers (beneath, regcache, regnum);
+      beneath->to_store_registers (beneath, regcache, ptid, regnum);
     }
 }
 

diff --git a/gdb/hppa-linux-nat.c b/gdb/hppa-linux-nat.c
index da1f914..ff28313 100644
--- a/gdb/hppa-linux-nat.c
+++ b/gdb/hppa-linux-nat.c

@@ -240,7 +240,7 @@
 /* Store one register.  */
 
 static void
-store_register (const struct regcache *regcache, int regno)
+store_register (const struct regcache *regcache, ptid_t ptid, int regno)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int tid;
@@ -250,9 +250,9 @@
     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.  */
 
   errno = 0;
   regcache_raw_collect (regcache, regno, &val);
@@ -291,18 +291,19 @@
 
 static void
 hppa_linux_store_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++)
-	store_register (regcache, regno);
+	store_register (regcache, regno, ptid);
     }
   else
     {
-      store_register (regcache, regno);
+      store_register (regcache, regno, ptid);
     }
 }
 

diff --git a/gdb/i386-linux-nat.c b/gdb/i386-linux-nat.c
index 7602f80..94f6809 100644
--- a/gdb/i386-linux-nat.c
+++ b/gdb/i386-linux-nat.c

@@ -123,7 +123,7 @@
 /* Store one register.  */
 
 static void
-store_register (const struct regcache *regcache, int regno)
+store_register (const struct regcache *regcache, ptid_t ptid, int regno)
 {
   int tid;
   int val;
@@ -133,9 +133,9 @@
     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.  */
 
   errno = 0;
   regcache_raw_collect (regcache, regno, &val);
@@ -535,7 +535,8 @@
    registers).  */
 static void
 i386_linux_store_inferior_registers (struct target_ops *ops,
-				     struct regcache *regcache, int regno)
+				     struct regcache *regcache,
+				     ptid_t ptid, int regno)
 {
   int tid;
 
@@ -547,15 +548,15 @@
 
       for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
 	if (regno == -1 || regno == i)
-	  store_register (regcache, i);
+	  store_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_SETFPXREGS requests whenever possible, since it
      transfers more registers in one system call.  But remember that

diff --git a/gdb/ia64-linux-nat.c b/gdb/ia64-linux-nat.c
index da3fdae..7c00c5b 100644
--- a/gdb/ia64-linux-nat.c
+++ b/gdb/ia64-linux-nat.c

@@ -783,7 +783,8 @@
 /* Store register REGNUM into the inferior.  */
 
 static void
-ia64_linux_store_register (const struct regcache *regcache, int regnum)
+ia64_linux_store_register (const struct regcache *regcache,
+			   ptid_t ptid, int regnum)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   CORE_ADDR addr;
@@ -796,9 +797,9 @@
 
   /* 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);
@@ -827,15 +828,16 @@
 
 static void
 ia64_linux_store_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_store_register (regcache, regnum);
+      ia64_linux_store_register (regcache, ptid, regnum);
   else
-    ia64_linux_store_register (regcache, regnum);
+    ia64_linux_store_register (regcache, ptid, regnum);
 }
 
 

diff --git a/gdb/inf-child.c b/gdb/inf-child.c
index 49445dd..0f128c4 100644
--- a/gdb/inf-child.c
+++ b/gdb/inf-child.c

@@ -91,7 +91,8 @@
 
 static void
 inf_child_store_inferior_registers (struct target_ops *ops,
-				    struct regcache *regcache, int regnum)
+				    struct regcache *regcache,
+				    ptid_t ptid, int regnum)
 {
 }
 

diff --git a/gdb/inf-ptrace.c b/gdb/inf-ptrace.c
index 3cc6a13..cf9cf5e 100644
--- a/gdb/inf-ptrace.c
+++ b/gdb/inf-ptrace.c

@@ -767,7 +767,8 @@
 /* Store register REGNUM into the inferior.  */
 
 static void
-inf_ptrace_store_register (const struct regcache *regcache, int regnum)
+inf_ptrace_store_register (const struct regcache *regcache,
+			   ptid_t ptid, int regnum)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   CORE_ADDR addr;
@@ -783,9 +784,9 @@
 
   /* 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);
@@ -811,15 +812,16 @@
 
 static void
 inf_ptrace_store_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++)
-      inf_ptrace_store_register (regcache, regnum);
+      inf_ptrace_store_register (regcache, ptid, regnum);
   else
-    inf_ptrace_store_register (regcache, regnum);
+    inf_ptrace_store_register (regcache, ptid, regnum);
 }
 
 /* Create a "traditional" ptrace target.  REGISTER_U_OFFSET should be

diff --git a/gdb/m68k-linux-nat.c b/gdb/m68k-linux-nat.c
index d7403e5..b39459d 100644
--- a/gdb/m68k-linux-nat.c
+++ b/gdb/m68k-linux-nat.c

@@ -154,7 +154,7 @@
 /* Store one register.  */
 
 static void
-store_register (const struct regcache *regcache, int regno)
+store_register (const struct regcache *regcache, ptid_t ptid, int regno)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   long regaddr, val;
@@ -163,9 +163,9 @@
   gdb_byte buf[M68K_MAX_REGISTER_SIZE];
 
   /* 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];
@@ -192,11 +192,12 @@
    Otherwise, REGNO specifies which register (so we can save time).  */
 
 static void
-old_store_inferior_registers (const struct regcache *regcache, int regno)
+old_store_inferior_registers (const struct regcache *regcache,
+			      ptid_t ptid, int regno)
 {
   if (regno >= 0)
     {
-      store_register (regcache, regno);
+      store_register (regcache, ptid, regno);
     }
   else
     {
@@ -204,7 +205,7 @@
 	   regno < gdbarch_num_regs (get_regcache_arch (regcache));
 	   regno++)
 	{
-	  store_register (regcache, regno);
+	  store_register (regcache, ptid, regno);
 	}
     }
 }
@@ -462,7 +463,8 @@
    registers).  */
 static void
 m68k_linux_store_inferior_registers (struct target_ops *ops,
-				     struct regcache *regcache, int regno)
+				     struct regcache *regcache,
+				     ptid_t ptid, int regno)
 {
   int tid;
 
@@ -470,14 +472,14 @@
      SETREGS request isn't available.  */
   if (! have_ptrace_getregs)
     {
-      old_store_inferior_registers (regcache, regno);
+      old_store_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_SETFPREGS requests whenever possible, since it
      transfers more registers in one system call.  But remember that

diff --git a/gdb/mips-linux-nat.c b/gdb/mips-linux-nat.c
index f9b6e1b..8456cc0 100644
--- a/gdb/mips-linux-nat.c
+++ b/gdb/mips-linux-nat.c

@@ -56,7 +56,7 @@
 static void (*super_fetch_registers) (struct target_ops *,
 				      struct regcache *, ptid_t, int);
 static void (*super_store_registers) (struct target_ops *,
-				      struct regcache *, int);
+				      struct regcache *, ptid_t, int);
 
 static void (*super_close) (struct target_ops *);
 
@@ -304,7 +304,8 @@
 
 static void
 mips64_linux_regsets_store_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;
@@ -334,9 +335,9 @@
   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))
     {
@@ -367,14 +368,14 @@
     }
 
   if (is_dsp)
-    super_store_registers (ops, regcache, regno);
+    super_store_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_store_registers (ops, regcache, regi);
-      super_store_registers (ops, regcache, mips_regnum (gdbarch)->dspctl);
+	super_store_registers (ops, regcache, ptid, regi);
+      super_store_registers (ops, regcache, ptid, mips_regnum (gdbarch)->dspctl);
     }
 }
 
@@ -401,16 +402,17 @@
 
 static void
 mips64_linux_store_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_store_registers (ops, regcache, regnum);
+    mips64_linux_regsets_store_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_store_registers (ops, regcache, regnum);
+    super_store_registers (ops, regcache, ptid, regnum);
 }
 
 /* Return the address in the core dump or inferior of register

diff --git a/gdb/ppc-linux-nat.c b/gdb/ppc-linux-nat.c
index e7070cc..a35e068 100644
--- a/gdb/ppc-linux-nat.c
+++ b/gdb/ppc-linux-nat.c

@@ -2290,14 +2290,15 @@
 
 static void
 ppc_linux_store_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 >= 0)
     store_register (regcache, tid, regno);

diff --git a/gdb/ppc-nbsd-nat.c b/gdb/ppc-nbsd-nat.c
index f2b837b..13a6382 100644
--- a/gdb/ppc-nbsd-nat.c
+++ b/gdb/ppc-nbsd-nat.c

@@ -110,7 +110,8 @@
 
 static void
 ppcnbsd_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);
 
@@ -118,14 +119,14 @@
     {
       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"));
 
       ppc_collect_gregset (&ppcnbsd_gregset, regcache,
 			   regnum, &regs, sizeof regs);
 
-      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"));
     }
@@ -134,14 +135,14 @@
     {
       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"));
 
       ppc_collect_fpregset (&ppcnbsd_fpregset, regcache,
 			    regnum, &fpregs, sizeof fpregs);
 
-      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 set FP registers"));
     }

diff --git a/gdb/ppc-obsd-nat.c b/gdb/ppc-obsd-nat.c
index 0bb6f9f..09a6ace 100644
--- a/gdb/ppc-obsd-nat.c
+++ b/gdb/ppc-obsd-nat.c

@@ -109,11 +109,12 @@
 
 static void
 ppcobsd_store_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"));
 
@@ -124,7 +125,7 @@
 			regnum, &regs, sizeof regs);
 #endif
 
-  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"));
 
@@ -134,14 +135,14 @@
     {
       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"));
 
       ppc_collect_fpregset (&ppcobsd_fpregset, regcache,
 			    regnum, &fpregs, sizeof fpregs);
 
-      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"));
     }

diff --git a/gdb/ppc-ravenscar-thread.c b/gdb/ppc-ravenscar-thread.c
index 9f518c2..1e4eb03 100644
--- a/gdb/ppc-ravenscar-thread.c
+++ b/gdb/ppc-ravenscar-thread.c

@@ -184,7 +184,7 @@
 static void
 ppc_ravenscar_generic_store_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);
   int buf_size = register_size (gdbarch, regnum);
@@ -193,7 +193,7 @@
 
   if (register_in_thread_descriptor_p (reg_info, regnum))
     register_address
-      = ptid_get_tid (inferior_ptid) + reg_info->context_offsets [regnum];
+      = ptid_get_tid (ptid) + reg_info->context_offsets [regnum];
   else
     return;
 
@@ -225,9 +225,10 @@
    for most PowerPC targets.  */
 
 static void
-ppc_ravenscar_powerpc_store_registers (struct regcache *regcache, int regnum)
+ppc_ravenscar_powerpc_store_registers (struct regcache *regcache, ptid_t ptid,
+				       int regnum)
 {
-  ppc_ravenscar_generic_store_registers (&ppc_reg_info, regcache, regnum);
+  ppc_ravenscar_generic_store_registers (&ppc_reg_info, regcache, ptid, regnum);
 }
 
 /* The ravenscar_arch_ops vector for most PowerPC targets.  */
@@ -270,9 +271,11 @@
    for E500 targets.  */
 
 static void
-ppc_ravenscar_e500_store_registers (struct regcache *regcache, int regnum)
+ppc_ravenscar_e500_store_registers (struct regcache *regcache, ptid_t ptid,
+				    int regnum)
 {
-  ppc_ravenscar_generic_store_registers (&e500_reg_info, regcache, regnum);
+  ppc_ravenscar_generic_store_registers (&e500_reg_info, regcache, ptid,
+					 regnum);
 }
 
 /* The ravenscar_arch_ops vector for E500 targets.  */

diff --git a/gdb/proc-service.c b/gdb/proc-service.c
index 188ad55..373c762 100644
--- a/gdb/proc-service.c
+++ b/gdb/proc-service.c

@@ -174,16 +174,13 @@
 ps_err_e
 ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, const 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 ());
-
+  regcache = get_thread_arch_regcache (ptid, target_gdbarch ());
   supply_gregset (regcache, (const gdb_gregset_t *) gregset);
-  target_store_registers (regcache, -1);
+  target_store_registers (regcache, ptid, -1);
 
-  do_cleanups (old_chain);
   return PS_OK;
 }
 
@@ -211,16 +208,13 @@
 ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
 	       const 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 ());
-
+  regcache = get_thread_arch_regcache (ptid, target_gdbarch ());
   supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset);
-  target_store_registers (regcache, -1);
+  target_store_registers (regcache, ptid, -1);
 
-  do_cleanups (old_chain);
   return PS_OK;
 }
 

diff --git a/gdb/procfs.c b/gdb/procfs.c
index c7b7dab..e98f68a 100644
--- a/gdb/procfs.c
+++ b/gdb/procfs.c

@@ -117,7 +117,7 @@
 static void procfs_fetch_registers (struct target_ops *,
 				    struct regcache *, ptid_t, int);
 static void procfs_store_registers (struct target_ops *,
-				    struct regcache *, int);
+				    struct regcache *, ptid_t, int);
 static void procfs_pass_signals (struct target_ops *self,
 				 int, unsigned char *);
 static void procfs_kill_inferior (struct target_ops *ops);
@@ -3265,19 +3265,20 @@
 
 static void
 procfs_store_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: store_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)

diff --git a/gdb/ravenscar-thread.c b/gdb/ravenscar-thread.c
index 12a4eab..0660d03 100644
--- a/gdb/ravenscar-thread.c
+++ b/gdb/ravenscar-thread.c

@@ -57,8 +57,6 @@
 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_store_registers (struct target_ops *ops,
-                                       struct regcache *regcache, int regnum);
 static void ravenscar_prepare_to_store (struct target_ops *self,
 					struct regcache *regcache);
 static void ravenscar_resume (struct target_ops *ops, ptid_t ptid, int step,
@@ -283,21 +281,22 @@
 
 static void
 ravenscar_store_registers (struct target_ops *ops,
-                           struct regcache *regcache, int regnum)
+                           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_store_registers (beneath, regcache, regnum);
+      || ptid_equal (ptid, base_magic_null_ptid)
+      || ptid_equal (ptid, ravenscar_running_thread ()))
+    beneath->to_store_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_store_registers (regcache, regnum);
+      arch_ops->to_store_registers (regcache, ptid, regnum);
     }
 }
 

diff --git a/gdb/ravenscar-thread.h b/gdb/ravenscar-thread.h
index 2413153..2df8898 100644
--- a/gdb/ravenscar-thread.h
+++ b/gdb/ravenscar-thread.h

@@ -25,7 +25,7 @@
 struct ravenscar_arch_ops
 {
   void (*to_fetch_registers) (struct regcache *, ptid_t, int);
-  void (*to_store_registers) (struct regcache *, int);
+  void (*to_store_registers) (struct regcache *, ptid_t, int);
   void (*to_prepare_to_store) (struct regcache *);
 };
 

diff --git a/gdb/record-btrace.c b/gdb/record-btrace.c
index 3f6cc85..6c16148 100644
--- a/gdb/record-btrace.c
+++ b/gdb/record-btrace.c

@@ -1462,18 +1462,19 @@
 
 static void
 record_btrace_store_registers (struct target_ops *ops,
-			       struct regcache *regcache, int regno)
+			       struct regcache *regcache,
+			       ptid_t ptid, int regno)
 {
   struct target_ops *t;
 
   if (!record_btrace_generating_corefile
-      && record_btrace_is_replaying (ops, inferior_ptid))
+      && record_btrace_is_replaying (ops, ptid))
     error (_("Cannot write registers while replaying."));
 
   gdb_assert (may_write_registers != 0);
 
   t = ops->beneath;
-  t->to_store_registers (t, regcache, regno);
+  t->to_store_registers (t, regcache, ptid, regno);
 }
 
 /* The to_prepare_to_store method of target record-btrace.  */

diff --git a/gdb/record-full.c b/gdb/record-full.c
index 0b04f0f..c55fb41 100644
--- a/gdb/record-full.c
+++ b/gdb/record-full.c

@@ -1459,7 +1459,7 @@
 static void
 record_full_store_registers (struct target_ops *ops,
 			     struct regcache *regcache,
-			     int regno)
+			     ptid_t ptid, int regno)
 {
   if (!record_full_gdb_operation_disable)
     {
@@ -1507,7 +1507,7 @@
 
       record_full_registers_change (regcache, regno);
     }
-  ops->beneath->to_store_registers (ops->beneath, regcache, regno);
+  ops->beneath->to_store_registers (ops->beneath, regcache, ptid, regno);
 }
 
 /* "to_xfer_partial" method.  Behavior is conditional on
@@ -2074,7 +2074,7 @@
 static void
 record_full_core_store_registers (struct target_ops *ops,
                              struct regcache *regcache,
-                             int regno)
+			     ptid_t ptid, int regno)
 {
   if (record_full_gdb_operation_disable)
     regcache_raw_collect (regcache, regno,

diff --git a/gdb/regcache.c b/gdb/regcache.c
index bdf0bcb..c8eb200 100644
--- a/gdb/regcache.c
+++ b/gdb/regcache.c

@@ -957,7 +957,7 @@
   chain_before_invalidate_register
     = make_cleanup_regcache_invalidate (regcache, regnum);
 
-  target_store_registers (regcache, regnum);
+  target_store_registers (regcache, regcache->ptid, regnum);
 
   /* The target did not throw an error so we can discard invalidating the
      register and restore the cleanup chain to what it was.  */

diff --git a/gdb/remote-sim.c b/gdb/remote-sim.c
index 609ae84..b7ecdbb 100644
--- a/gdb/remote-sim.c
+++ b/gdb/remote-sim.c

@@ -504,16 +504,18 @@
 
 static void
 gdbsim_store_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_store_register (ops, regcache, regno);
+	gdbsim_store_register (ops, regcache, ptid, regno);
       return;
     }
   else if (gdbarch_register_sim_regno (gdbarch, regno) >= 0)

diff --git a/gdb/remote.c b/gdb/remote.c
index b1b1c58..b7ffa4a 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c

@@ -7862,13 +7862,14 @@
 
 static void
 remote_store_registers (struct target_ops *ops,
-			struct regcache *regcache, int regnum)
+			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)
     {

diff --git a/gdb/rs6000-aix-tdep.c b/gdb/rs6000-aix-tdep.c
index 9841a60..3cd0350 100644
--- a/gdb/rs6000-aix-tdep.c
+++ b/gdb/rs6000-aix-tdep.c

@@ -37,6 +37,7 @@
 #include "solib.h"
 #include "solib-aix.h"
 #include "xml-utils.h"
+#include "inferior.h"
 
 /* If the kernel has to deliver a signal, it pushes a sigcontext
    structure on the stack and then calls the signal handler, passing
@@ -407,7 +408,7 @@
   regcache_raw_write_signed (regcache, tdep->ppc_toc_regnum,
 			     solib_aix_get_toc_value (func_addr));
 
-  target_store_registers (regcache, -1);
+  target_store_registers (regcache, inferior_ptid, -1);
   return sp;
 }
 

diff --git a/gdb/rs6000-lynx178-tdep.c b/gdb/rs6000-lynx178-tdep.c
index f2aa1f8..600084f 100644
--- a/gdb/rs6000-lynx178-tdep.c
+++ b/gdb/rs6000-lynx178-tdep.c

@@ -24,6 +24,7 @@
 #include "ppc-tdep.h"
 #include "value.h"
 #include "xcoffread.h"
+#include "inferior.h"
 
 /* Implement the "push_dummy_call" gdbarch method.  */
 
@@ -256,7 +257,7 @@
      breakpoint.  */
   regcache_raw_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr);
 
-  target_store_registers (regcache, -1);
+  target_store_registers (regcache, inferior_ptid, -1);
   return sp;
 }
 

diff --git a/gdb/rs6000-nat.c b/gdb/rs6000-nat.c
index 7362df9..6f3f807 100644
--- a/gdb/rs6000-nat.c
+++ b/gdb/rs6000-nat.c

@@ -219,7 +219,7 @@
 /* Store register REGNO back into the inferior.  */
 
 static void
-store_register (struct regcache *regcache, int regno)
+store_register (struct regcache *regcache, ptid_t ptid, int regno)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int addr[MAX_REGISTER_SIZE];
@@ -235,7 +235,7 @@
 
   /* Floating-point registers.  */
   if (isfloat)
-    rs6000_ptrace32 (PT_WRITE_FPR, ptid_get_pid (inferior_ptid), addr, nr, 0);
+    rs6000_ptrace32 (PT_WRITE_FPR, ptid_get_pid (ptid), addr, nr, 0);
 
   /* Bogus register number.  */
   else if (nr < 0)
@@ -253,7 +253,7 @@
          the register's value is passed by value, but for 64-bit inferiors,
 	 the address of a buffer containing the value is passed.  */
       if (!ARCH64 ())
-	rs6000_ptrace32 (PT_WRITE_GPR, ptid_get_pid (inferior_ptid),
+	rs6000_ptrace32 (PT_WRITE_GPR, ptid_get_pid (ptid),
 			 (int *) nr, *addr, 0);
       else
 	{
@@ -264,7 +264,7 @@
 	    memcpy (&buf, addr, 8);
 	  else
 	    buf = *addr;
-	  rs6000_ptrace64 (PT_WRITE_GPR, ptid_get_pid (inferior_ptid),
+	  rs6000_ptrace64 (PT_WRITE_GPR, ptid_get_pid (ptid),
 			   nr, 0, &buf);
 	}
     }
@@ -325,11 +325,12 @@
 
 static void
 rs6000_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)
-    store_register (regcache, regno);
+    store_register (regcache, ptid, regno);
 
   else
     {
@@ -340,25 +341,25 @@
            regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
 	   regno++)
 	{
-	  store_register (regcache, regno);
+	  store_register (regcache, ptid, regno);
 	}
 
       /* Write floating point registers.  */
       if (tdep->ppc_fp0_regnum >= 0)
         for (regno = 0; regno < ppc_num_fprs; regno++)
-          store_register (regcache, tdep->ppc_fp0_regnum + regno);
+          store_register (regcache, ptid, tdep->ppc_fp0_regnum + regno);
 
       /* Write special registers.  */
-      store_register (regcache, gdbarch_pc_regnum (gdbarch));
-      store_register (regcache, tdep->ppc_ps_regnum);
-      store_register (regcache, tdep->ppc_cr_regnum);
-      store_register (regcache, tdep->ppc_lr_regnum);
-      store_register (regcache, tdep->ppc_ctr_regnum);
-      store_register (regcache, tdep->ppc_xer_regnum);
+      store_register (regcache, ptid, gdbarch_pc_regnum (gdbarch));
+      store_register (regcache, ptid, tdep->ppc_ps_regnum);
+      store_register (regcache, ptid, tdep->ppc_cr_regnum);
+      store_register (regcache, ptid, tdep->ppc_lr_regnum);
+      store_register (regcache, ptid, tdep->ppc_ctr_regnum);
+      store_register (regcache, ptid, tdep->ppc_xer_regnum);
       if (tdep->ppc_fpscr_regnum >= 0)
-        store_register (regcache, tdep->ppc_fpscr_regnum);
+        store_register (regcache, ptid, tdep->ppc_fpscr_regnum);
       if (tdep->ppc_mq_regnum >= 0)
-	store_register (regcache, tdep->ppc_mq_regnum);
+	store_register (regcache, ptid, tdep->ppc_mq_regnum);
     }
 }
 

diff --git a/gdb/s390-linux-nat.c b/gdb/s390-linux-nat.c
index 1703844..15fab43 100644
--- a/gdb/s390-linux-nat.c
+++ b/gdb/s390-linux-nat.c

@@ -420,9 +420,10 @@
    -1, do this for all registers.  */
 static void
 s390_linux_store_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))
     store_regs (regcache, tid, regnum);

diff --git a/gdb/sh-nbsd-nat.c b/gdb/sh-nbsd-nat.c
index d1ece86..4d1794f 100644
--- a/gdb/sh-nbsd-nat.c
+++ b/gdb/sh-nbsd-nat.c

@@ -65,13 +65,14 @@
 
 static void
 shnbsd_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 (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"));
 
@@ -79,7 +80,7 @@
 				  (char *) &inferior_registers,
 				  SHNBSD_SIZEOF_GREGS);
 
-      if (ptrace (PT_SETREGS, ptid_get_pid (inferior_ptid),
+      if (ptrace (PT_SETREGS, ptid_get_pid (ptid),
 		  (PTRACE_TYPE_ARG3) &inferior_registers, 0) == -1)
 	perror_with_name (_("Couldn't set registers"));
 

diff --git a/gdb/sol-thread.c b/gdb/sol-thread.c
index 56fdc96..bd20cba 100644
--- a/gdb/sol-thread.c
+++ b/gdb/sol-thread.c

@@ -508,7 +508,8 @@
 
 static void
 sol_thread_store_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;
@@ -516,17 +517,17 @@
   prgregset_t gregset;
   prfpregset_t fpregset;
 
-  if (!ptid_tid_p (inferior_ptid))
+  if (!ptid_tid_p (ptid))
     {
       struct target_ops *beneath = find_target_beneath (ops);
 
       /* It's an LWP; pass the request on to the layer beneath.  */
-      beneath->to_store_registers (beneath, regcache, regnum);
+      beneath->to_store_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);
 
   val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
   if (val != TD_OK)

diff --git a/gdb/sparc-nat.c b/gdb/sparc-nat.c
index b423ce5..f0bcc13 100644
--- a/gdb/sparc-nat.c
+++ b/gdb/sparc-nat.c

@@ -191,16 +191,17 @@
 
 void
 sparc_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);
   int pid;
 
   /* NOTE: cagney/2002-12-02: See comment in fetch_inferior_registers
      about threaded assumptions.  */
-  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 == -1 || sparc_gregset_supplies_p (gdbarch, regnum))
     {

diff --git a/gdb/sparc-nat.h b/gdb/sparc-nat.h
index bfa6961..4ab8130 100644
--- a/gdb/sparc-nat.h
+++ b/gdb/sparc-nat.h

@@ -47,6 +47,6 @@
 extern void sparc_fetch_inferior_registers (struct target_ops *,
 					    struct regcache *, ptid_t, int);
 extern void sparc_store_inferior_registers (struct target_ops *,
-					    struct regcache *, int);
+					    struct regcache *, ptid_t, int);
 
 #endif /* sparc-nat.h */

diff --git a/gdb/sparc-ravenscar-thread.c b/gdb/sparc-ravenscar-thread.c
index 0573f83..4e63ec5 100644
--- a/gdb/sparc-ravenscar-thread.c
+++ b/gdb/sparc-ravenscar-thread.c

@@ -25,8 +25,6 @@
 #include "ravenscar-thread.h"
 #include "sparc-ravenscar-thread.h"
 
-static void sparc_ravenscar_store_registers (struct regcache *regcache,
-                                             int regnum);
 static void sparc_ravenscar_prepare_to_store (struct regcache *regcache);
 
 /* Register offsets from a referenced address (exempli gratia the
@@ -152,7 +150,8 @@
    thread.  */
 
 static void
-sparc_ravenscar_store_registers (struct regcache *regcache, int regnum)
+sparc_ravenscar_store_registers (struct regcache *regcache, ptid_t ptid,
+				 int regnum)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int buf_size = register_size (gdbarch, regnum);
@@ -160,8 +159,7 @@
   ULONGEST register_address;
 
   if (register_in_thread_descriptor_p (regnum))
-    register_address =
-      ptid_get_tid (inferior_ptid) + sparc_register_offsets [regnum];
+    register_address = ptid_get_tid (ptid) + sparc_register_offsets [regnum];
   else if (register_on_stack_p (regnum))
     {
       regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM,

diff --git a/gdb/spu-linux-nat.c b/gdb/spu-linux-nat.c
index c5b9122..a0b2821 100644
--- a/gdb/spu-linux-nat.c
+++ b/gdb/spu-linux-nat.c

@@ -534,7 +534,8 @@
 /* Override the store_inferior_register routine.  */
 static void
 spu_store_inferior_registers (struct target_ops *ops,
-			      struct regcache *regcache, int regno)
+			      struct regcache *regcache,
+			      ptid_t ptid, int regno)
 {
   int fd;
   ULONGEST addr;

diff --git a/gdb/spu-multiarch.c b/gdb/spu-multiarch.c
index 6516a10..a079098 100644
--- a/gdb/spu-multiarch.c
+++ b/gdb/spu-multiarch.c

@@ -196,7 +196,7 @@
 /* Override the to_store_registers routine.  */
 static void
 spu_store_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 target_ops *ops_beneath = find_target_beneath (ops);
@@ -206,12 +206,12 @@
   /* This version applies only if we're currently in spu_run.  */
   if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_spu)
     {
-      ops_beneath->to_store_registers (ops_beneath, regcache, regno);
+      ops_beneath->to_store_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 NPC register is found in PPC memory at SPUFS_ADDR.  */

diff --git a/gdb/target-delegates.c b/gdb/target-delegates.c
index 01ab150..3f1c236 100644
--- a/gdb/target-delegates.c
+++ b/gdb/target-delegates.c

@@ -187,29 +187,31 @@
 }
 
 static void
-delegate_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
+delegate_store_registers (struct target_ops *self, struct regcache *arg1, ptid_t arg2, int arg3)
 {
   self = self->beneath;
-  self->to_store_registers (self, arg1, arg2);
+  self->to_store_registers (self, arg1, arg2, arg3);
 }
 
 static void
-tdefault_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
+tdefault_store_registers (struct target_ops *self, struct regcache *arg1, ptid_t arg2, int arg3)
 {
   noprocess ();
 }
 
 static void
-debug_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
+debug_store_registers (struct target_ops *self, struct regcache *arg1, ptid_t arg2, int arg3)
 {
   fprintf_unfiltered (gdb_stdlog, "-> %s->to_store_registers (...)\n", debug_target.to_shortname);
-  debug_target.to_store_registers (&debug_target, arg1, arg2);
+  debug_target.to_store_registers (&debug_target, arg1, arg2, arg3);
   fprintf_unfiltered (gdb_stdlog, "<- %s->to_store_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);
 }
 

diff --git a/gdb/target.c b/gdb/target.c
index e57789f..6ce0921 100644
--- a/gdb/target.c
+++ b/gdb/target.c

@@ -3593,12 +3593,12 @@
 }
 
 void
-target_store_registers (struct regcache *regcache, int regno)
+target_store_registers (struct regcache *regcache, ptid_t ptid, int regno)
 {
   if (!may_write_registers)
     error (_("Writing to registers is not allowed (regno %d)"), regno);
 
-  current_target.to_store_registers (&current_target, regcache, regno);
+  current_target.to_store_registers (&current_target, regcache, ptid, regno);
   if (targetdebug)
     {
       debug_print_register ("target_store_registers", regcache, regno);

diff --git a/gdb/target.h b/gdb/target.h
index 24a138f..d6c07ad 100644
--- a/gdb/target.h
+++ b/gdb/target.h

@@ -471,7 +471,8 @@
     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)
+    void (*to_store_registers) (struct target_ops *, struct regcache *, ptid_t,
+			        int)
       TARGET_DEFAULT_NORETURN (noprocess ());
     void (*to_prepare_to_store) (struct target_ops *, struct regcache *)
       TARGET_DEFAULT_NORETURN (noprocess ());
@@ -1391,7 +1392,8 @@
    It can store as many registers as it wants to, so target_prepare_to_store
    must have been previously called.  Calls error() if there are problems.  */
 
-extern void target_store_registers (struct regcache *regcache, int regs);
+extern void target_store_registers (struct regcache *regcache, ptid_t ptid,
+				    int regs);
 
 /* Get ready to modify the registers array.  On machines which store
    individual registers, this doesn't need to do anything.  On machines

diff --git a/gdb/tilegx-linux-nat.c b/gdb/tilegx-linux-nat.c
index 5c47a3e..f3e747b 100644
--- a/gdb/tilegx-linux-nat.c
+++ b/gdb/tilegx-linux-nat.c

@@ -144,14 +144,15 @@
 
 static void
 store_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"));

diff --git a/gdb/vax-bsd-nat.c b/gdb/vax-bsd-nat.c
index 8d1cdf4..dfc8c8c 100644
--- a/gdb/vax-bsd-nat.c
+++ b/gdb/vax-bsd-nat.c

@@ -81,17 +81,18 @@
 
 static void
 vaxbsd_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"));
 
   vaxbsd_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"));
 }

diff --git a/gdb/windows-nat.c b/gdb/windows-nat.c
index 36ca90d..2fa772a 100644
--- a/gdb/windows-nat.c
+++ b/gdb/windows-nat.c

@@ -559,9 +559,10 @@
 /* Store a new register value into the current thread context.  */
 static void
 windows_store_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.  */

diff --git a/gdb/xtensa-linux-nat.c b/gdb/xtensa-linux-nat.c
index 688ed5c..467c249 100644
--- a/gdb/xtensa-linux-nat.c
+++ b/gdb/xtensa-linux-nat.c

@@ -187,13 +187,13 @@
   supply_gregset_reg (regcache, &regs, regnum);
 }
 
-/* Store greg-register(s) in GDB's register 
-   array into the process/thread specified by TID.  */
+/* Store greg-register(s) in REGCACHE into the process/thread specified by
+   PTID.  */
 
 static void
-store_gregs (struct regcache *regcache, int regnum)
+store_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;
 
@@ -235,9 +235,9 @@
 }
 
 static void
-store_xtregs (struct regcache *regcache, int regnum)
+store_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];
 
@@ -271,17 +271,18 @@
 
 static void
 xtensa_linux_store_inferior_registers (struct target_ops *ops,
-				       struct regcache *regcache, int regnum)
+				       struct regcache *regcache,
+				       ptid_t ptid, int regnum)
 {
   if (regnum == -1)
     {
-      store_gregs (regcache, regnum);
-      store_xtregs (regcache, regnum);
+      store_gregs (regcache, ptid, regnum);
+      store_xtregs (regcache, ptid, regnum);
     }
   else if ((regnum < xtreg_lo) || (regnum > xtreg_high))
-    store_gregs (regcache, regnum);
+    store_gregs (regcache, ptid, regnum);
   else
-    store_xtregs (regcache, regnum);
+    store_xtregs (regcache, ptid, regnum);
 }
 
 /* Called by libthread_db.  */