[commit] displaced stepping queue, multi-process

[Pedro Alves <pedro at codesourcery dot com>]

Hi guys,

Here's another patch preparing for remote non-stop + multiprocess
support.

This patch makes displaced stepping behave in a multi-process environment.
Many times, we'd have inferior_ptid pointing at thread a of process A, and
tried to ool step thread b of process B.  The result of this was that
simple_displaced_step_copy_insn would read/write memory from the
wrong process, causing weird looking SIGSEGVs to happen in the inferior.

This still leaves a single displaced stepping queue for all inferiors.
This could be optimized into a queue per-inferior, but I'm going for
correctness first.

Tested on x86-pc-linux, and checked in.

-- 
Pedro Alves

2008-10-14  Pedro Alves  <pedro@codesourcery.com>

	* infrun.c (displaced_step_prepare): Switch thread temporarily
	while we're here.
	(displaced_step_fixup): Make sure target_resume sees ptid as
	inferior_ptid.  Add debug output.

---
 gdb/infrun.c |   32 +++++++++++++++++++++++++-------
 1 file changed, 25 insertions(+), 7 deletions(-)

Index: src/gdb/infrun.c
===================================================================
--- src.orig/gdb/infrun.c	2008-10-15 00:35:50.000000000 +0100
+++ src/gdb/infrun.c	2008-10-15 00:36:49.000000000 +0100
@@ -629,7 +629,7 @@ displaced_step_dump_bytes (struct ui_fil
 static int
 displaced_step_prepare (ptid_t ptid)
 {
-  struct cleanup *old_cleanups;
+  struct cleanup *old_cleanups, *ignore_cleanups;
   struct regcache *regcache = get_thread_regcache (ptid);
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   CORE_ADDR original, copy;
@@ -681,6 +681,9 @@ displaced_step_prepare (ptid_t ptid)
 
   displaced_step_clear ();
 
+  old_cleanups = save_inferior_ptid ();
+  inferior_ptid = ptid;
+
   original = regcache_read_pc (regcache);
 
   copy = gdbarch_displaced_step_location (gdbarch);
@@ -688,8 +691,8 @@ displaced_step_prepare (ptid_t ptid)
 
   /* Save the original contents of the copy area.  */
   displaced_step_saved_copy = xmalloc (len);
-  old_cleanups = make_cleanup (free_current_contents,
-                               &displaced_step_saved_copy);
+  ignore_cleanups = make_cleanup (free_current_contents,
+				  &displaced_step_saved_copy);
   read_memory (copy, displaced_step_saved_copy, len);
   if (debug_displaced)
     {
@@ -699,7 +702,7 @@ displaced_step_prepare (ptid_t ptid)
     };
 
   closure = gdbarch_displaced_step_copy_insn (gdbarch,
-                                              original, copy, regcache);
+					      original, copy, regcache);
 
   /* We don't support the fully-simulated case at present.  */
   gdb_assert (closure);
@@ -709,11 +712,13 @@ displaced_step_prepare (ptid_t ptid)
   /* Resume execution at the copy.  */
   regcache_write_pc (regcache, copy);
 
-  discard_cleanups (old_cleanups);
+  discard_cleanups (ignore_cleanups);
+
+  do_cleanups (old_cleanups);
 
   if (debug_displaced)
     fprintf_unfiltered (gdb_stdlog, "displaced: displaced pc to 0x%s\n",
-                        paddr_nz (copy));
+			paddr_nz (copy));
 
   /* Save the information we need to fix things up if the step
      succeeds.  */
@@ -801,9 +806,22 @@ displaced_step_fixup (ptid_t event_ptid,
 			    "displaced: stepping queued %s now\n",
 			    target_pid_to_str (ptid));
 
-
       displaced_step_ptid = null_ptid;
       displaced_step_prepare (ptid);
+      context_switch (ptid);
+
+      if (debug_displaced)
+	{
+	  struct regcache *resume_regcache = get_thread_regcache (ptid);
+	  CORE_ADDR actual_pc = regcache_read_pc (resume_regcache);
+	  gdb_byte buf[4];
+
+	  fprintf_unfiltered (gdb_stdlog, "displaced: run 0x%s: ",
+			      paddr_nz (actual_pc));
+	  read_memory (actual_pc, buf, sizeof (buf));
+	  displaced_step_dump_bytes (gdb_stdlog, buf, sizeof (buf));
+	}
+
       target_resume (ptid, 1, TARGET_SIGNAL_0);
     }
 }